# compression

***

**1. Compressing and Decompressing Files**

```javascript
const zlib = require('zlib');
const fs = require('fs');

// Compress a file
zlib.gzip(fs.readFileSync('input.txt'), (err, buffer) => {
  if (err) throw err;
  fs.writeFileSync('input.txt.gz', buffer);
});

// Decompress a file
zlib.gunzip(fs.readFileSync('input.txt.gz'), (err, buffer) => {
  if (err) throw err;
  fs.writeFileSync('input.txt', buffer);
});
```

**2. Compressing and Decompressing Streams**

```javascript
const zlib = require('zlib');
const fs = require('fs');
const http = require('http');

// Compress a stream
http.createServer((req, res) => {
  res.writeHead(200, {
    'Content-Encoding': 'gzip',
  });
  zlib.gzip(fs.createReadStream('input.txt')).pipe(res);
}).listen(3000);

// Decompress a stream
http.get('http://localhost:3000', (res) => {
  zlib.gunzip(res).pipe(fs.createWriteStream('output.txt'));
});
```

**3. Data Reduction**

```javascript
const zstd = require('@emscripten-core/zstd');

const data = Buffer.from('Hello, world!');
const compressed = zstd.compressSync(data);
const decompressed = zstd.decompressSync(compressed);

console.log(data.length, compressed.length, decompressed.toString());
```

**4. Image Optimization**

```javascript
const sharp = require('sharp');

sharp('input.jpg')
  .resize(500, 500)
  .jpeg({ quality: 80 })
  .toBuffer()
  .then((data) => {
    fs.writeFileSync('output.jpg', data);
  });
```

**5. Text Compression**

```javascript
const lz4 = require('lz4');

const text = 'Hello, world!';
const compressed = lz4.compress(text);
const decompressed = lz4.decompress(compressed);

console.log(text.length, compressed.length, decompressed.toString());
```

**6. Database Compression**

```javascript
const pg = require('pg');

const client = new pg.Client();
client.connect();

client.query('CREATE EXTENSION IF NOT EXISTS pg_lz4;')
  .then(() => {
    client.query('SELECT * FROM my_table ORDER BY id')
      .then((res) => {
        const rows = res.rows;
        const compressedRows = pg.lz4.compress(rows);
        const decompressedRows = pg.lz4.decompress(compressedRows);
        console.log(rows, compressedRows, decompressedRows);
      });
  })
  .finally(() => client.end());
```

**7. Cache Compression**

```javascript
const redis = require('redis');
const redisAsync = redis.createClient();

redisAsync.set('my_key', 'Hello, world!', 'EX', 60, 'PXAT', 'LZ4');

redisAsync.get('my_key', (err, value) => {
  if (err) throw err;
  const decompressedValue = redis.lz4.decompress(value);
  console.log(decompressedValue);
});
```

**8. Data Transfer Optimization**

```javascript
const socket = require('socket.io');
const zlib = require('zlib');

const io = socket();
io.on('connection', (socket) => {
  socket.on('message', (msg) => {
    socket.emit('message', zlib.gzipSync(msg));
  });
});
```

**9. Cloud Storage Compression**

```javascript
const { Storage } = require('@google-cloud/storage');
const storage = new Storage();

const bucket = storage.bucket('my-bucket');
bucket.upload('input.txt', {
  destination: 'input.txt.gz',
  gzip: true,
});
```

**10. Archive Creation**

```javascript
const archiver = require('archiver');

const archive = archiver('zip', {
  zlib: { level: 9 },
});
archive.append('input.txt', { name: 'input.txt' });
archive.pipe(fs.createWriteStream('archive.zip'));
archive.finalize();
```

**11. Code Deployment Optimization**

```javascript
const rollup = require('rollup');
const terser = require('terser');

rollup.rollup({
  input: 'input.js',
  plugins: [terser()],
}).then((bundle) => {
  const output = Terser.minify(bundle.generate().output[0].code);
  fs.writeFileSync('output.js', output.code);
});
```

**12. Data Encryption and Compression**

```javascript
const crypto = require('crypto');
const zlib = require('zlib');

const algorithm = 'aes-256-ctr';
const secret = 'my-secret';
const iv = '1234567890';
const cipher = crypto.createCipheriv(algorithm, secret, iv);

cipher.pipe(zlib.createGzip()).pipe(fs.createWriteStream('output.gz'));
```

**13. Data Backup Compression**

```javascript
const backup = require('pg-backup');

backup('postgres://user:password@host:port/database')
  .compress()
  .toDirectory('/path/to/backup', { compress: true });
```

**14. Content Delivery Network (CDN) Optimization**

```javascript
const cloudflare = require('cloudflare');

const cf = new cloudflare({
  apiKey: 'my-api-key',
  email: 'my-email-address',
});

cf.zones.list()
  .then((zones) => {
    const zone = zones[0];
    const pageRule = {
      name: 'Compress Images',
      priority: 1,
      conditions: [{ type: 'uri', operator: 'matches', value: '^/images/' }],
      actions: [{ id: 'image_optimizer', value: {} }],
    };
    cf.zones.addPageRule(zone.id, pageRule);
  });
```

**15. Asynchronous Compression**

```javascript
const streamifier = require('streamifier');
const async = require('async');

const input = ['input1.txt', 'input2.txt'];
const output = 'output.zip';

async.eachSeries(input, (file, next) => {
  const zippedFile = streamifier.createReadStream(fs.createReadStream(file)).pipe(zlib.createGzip());
  zippedFile.pipe(fs.createWriteStream(output, { flags: 'a' }));
  zippedFile.on('finish', next);
}, (err) => {
  if (err) throw err;
});
```

**16. Non-Blocking Compression**

```javascript
const fs = require('fs');
const zlib = require('zlib');

fs.createReadStream('input.txt')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('output.gz'))
  .on('finish', () => {
    console.log('Compression complete');
  });
```

**17. Multi-Threaded Compression**

```javascript
const zlib = require('zlib');
const cluster = require('cluster');

const numCPUs = cluster.hardware.cpus.length;
const files = ['input1.txt', 'input2.txt'];

cluster.setupMaster({
  exec: compress,
  args: [numCPUs, files],
});

cluster.fork();
cluster.fork();

function compress(numCPUs, files) {
  const pools = [];
  for (let i = 0; i < numCPUs; i++) pools.push([]);

  files.forEach((file) => {
    const workerIndex = pools.map((pool) => pool.length).indexOf(Math.min(...pools.map((pool) => pool.length)));
    pools[workerIndex].push(file);
  });

  pools.forEach((pool, index) => {
    const worker = cluster.worker[index];
    worker.send({ pool: pool });
    worker.on('message', (msg) => { console.log(msg); });
  });
}
```

**18. Virtual Machine (VM) Image Compression**

```javascript
const Compute = require('@google-cloud/compute');
const compute = new Compute({
  projectId: 'my-project',
  keyFilename: '/path/to/service-account.json',
});

compute.getDisk('disk-name', (err, disk, apiResponse) => {
  if (err) throw err;

  const createImageRequest = {
    disk: `zones/${disk.zone}/disks/${disk.name}`,
    imageResource: {
      name: 'my-image',
      sourceDisk: `zones/${disk.zone}/disks/${disk.name}`,
      storageLocations: ['us-east1'],
    },
    forceCreate: true,
  };
  compute.createImage(createImageRequest, (err, operation, apiResponse) => {
    if (err) throw err;

    operation.on('complete', (operation, info, apiResponse) => {
      if (err) throw err;

      const diskImage = info.image || info.operation.targetLink;
      console.log(`Disk image created at ${diskImage}`);
    });
  });
});
```

**19. Database Table Compression**

```javascript
const pg = require('pg');

const client = new pg.Client();
client.connect();

client.query('ALTER TABLE my_table SET (compression = lz4);')
  .then(() => {
    client.query('SELECT * FROM my_table')
      .then((res) => {
        const rows = res.rows;
        console.log(rows);
      });
  })
  .finally(() => client.end());
```

**20. Audio File Compression**

```javascript
const opus = require('node-opus');

const encoder = new opus.Encoder({
  sampleRate: 48000,
  channels: 2,
  bitrate: 64000,
});
encoder.encode(audioData).then((compressedData) => {
  fs.writeFileSync('output.opus', compressedData);
});
```

**21. Video File Compression**

```javascript
const ffmpeg = require('ffmpeg-static');
const ffprobe = require('ffprobe-static');

ffmpeg({
  source: 'input.mp4',
  videoCodec: 'libx264',
  audioCodec: 'aac',
  crf: 25,
  fps: 30,
  output: 'output.mp4',
}).run((err, output, stderr) => {
  if (err) throw err;

  ffprobe(output.path, (err, info) => {
    if (err) throw err;

    console.log(info);
  });
});
```

**22. Image Thumbnail Generation and Compression**

```javascript
const sharp = require('sharp');

sharp('input.jpg')
  .resize(250, 250)
  .jpeg({ quality: 80 })
  .toBuffer()
  .then((data) => {
    fs.writeFileSync('thumbnail.jpg', data);
  });
```

**23. PDF Compression**

```javascript
const pdfjs = require('pdfjs-dist');
const fs = require('fs');

const pdf = await pdfjs.getDocument(fs.readFileSync('input.pdf'));
const page = await pdf.getPage(1);
const canvas = await page.getViewport(1.0);
const context = canvas.getContext('2d');
await page.render({ canvasContext: context });

const outputStream = fs.createWriteStream('output.pdf');
canvas.toPDF({}, outputStream);
outputStream.end();
```

**24. JSON Data Compression**

```javascript
const msgpack = require('msgpack-lite');

const data = {
  name: 'John Doe',
  age: 30,
  address: '123 Main Street',
};
const compressed = msgpack.encode(data);
const decompressed = msgpack.decode(compressed);

console.log(data, compressed, decompressed);
```

**25. WebSocket Data Compression**

```javascript
const WebSocket = require('ws');
const zlib = require('zlib');

const wss = new WebSocket.Server({ port: 8080 });
const clients = [];

wss.on('connection', (ws) => {
  clients.push(ws);

  ws.on('message', (msg) => {
    const compressed = zlib.gzipSync(msg);
    clients.forEach((client) => {
      if (client !== ws) client.send(compressed);
    });
  });

  ws.on('close', () => {
    clients.splice(clients.indexOf(ws), 1);
  });
});
```