Developer One-Liners: Time-Saving One-Liners Every Developer Should Know

# Traditional approach — 3 lines, 1 temp variable
temp = a
a = b
b = temp

# ✅ Python one-liner — tuple unpacking
a, b = b, a

# Why it works: Python evaluates the right side completely first,
# creating a tuple (b, a), then unpacks it into a and b.
# No temporary variable, no mutation during evaluation.
# Works for any number of variables:
x, y, z = z, x, y # rotate three values

from collections import Counter

data = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']

# ✅ One-liner: find mode
most_common = Counter(data).most_common(1)[0][0]
# Result: 'apple'

# Top N most common:
top3 = [item for item, _ in Counter(data).most_common(3)]
# Result: ['apple', 'banana', 'cherry']

# Real use case: find most common HTTP status code in logs
from collections import Counter
status_codes = [int(line.split()[8]) for line in open('access.log') if len(line.split()) > 8]
print(Counter(status_codes).most_common(5))

nested = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]

# ✅ One-liner using itertools.chain
from itertools import chain
flat = list(chain.from_iterable(nested))
# Result: [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Alternative — list comprehension (slightly slower but no import)
flat = [item for sublist in nested for item in sublist]

# For deeply nested (arbitrary depth):
import json
flat_deep = json.loads(str(nested).replace('[','').replace(']','').split(','))
# Better: use a recursive generator for arbitrary depth

defaults = {'timeout': 30, 'retries': 3, 'verbose': False}
overrides = {'timeout': 60, 'debug': True}

# ✅ Python 3.9+ — merge operator
merged = defaults | overrides
# Result: {'timeout': 60, 'retries': 3, 'verbose': False, 'debug': True}
# Right side wins on conflicts

# Python 3.5+ alternative
merged = {**defaults, **overrides}

# In-place update
defaults |= overrides # Python 3.9+

from itertools import groupby

data = [1, 1, 2, 2, 2, 3, 1, 1]

# ✅ Group consecutive identical elements
groups = {k: list(v) for k, v in groupby(data)}
# Result: {1: [1, 1], 2: [2, 2, 2], 3: [3]}

# Group by a property (sort first for groupby to work correctly)
users = [{'name': 'Alice', 'dept': 'Eng'}, {'name': 'Bob', 'dept': 'Sales'}, {'name': 'Carol', 'dept': 'Eng'}]
by_dept = {k: list(v) for k, v in groupby(sorted(users, key=lambda x: x['dept']), key=lambda x: x['dept'])}
# Result: {'Eng': [Alice, Carol], 'Sales': [Bob]}

const original = { user: { name: 'Alice', scores: [95, 87, 92] } };

// ❌ Shallow copy — nested objects still share reference
const shallow = { ...original };

// ✅ Deep clone — structuredClone (modern, built-in, fast)
const deep = structuredClone(original);
deep.user.name = 'Bob';
console.log(original.user.name); // Still 'Alice' ✓

// structuredClone handles: Dates, Maps, Sets, RegExp, ArrayBuffers
// Does NOT handle: Functions, DOM nodes, class instances

// Older approach (avoid — doesn't handle Dates correctly):
const old = JSON.parse(JSON.stringify(original));

const arr = [1, 2, 3, 2, 1, 4, 3, 5];

// ✅ Remove duplicates — Set conversion
const unique = [...new Set(arr)];
// Result: [1, 2, 3, 4, 5]

// Remove duplicate objects by a key
const users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 1, name: 'Alice Clone' }];
const uniqueById = [...new Map(users.map(u => [u.id, u])).values()];
// Result: [{ id: 1, name: 'Alice Clone' }, { id: 2, name: 'Bob' }]
// Note: last duplicate wins (Alice Clone, not Alice)

const user = { profile: { address: null } };

// ❌ Old way — TypeError crashes if any level is null
const city = user.profile.address.city; // TypeError!

// ✅ Optional chaining — returns undefined instead of throwing
const city = user?.profile?.address?.city;
// Result: undefined (no crash)

// With nullish coalescing for defaults
const city = user?.profile?.address?.city ?? 'Unknown City';
// Result: 'Unknown City'

// Works on method calls too
const len = user?.profile?.getAddressCount?.() ?? 0;

// ✅ Random hex color in one line
const color = '#' + Math.floor(Math.random() * 0xFFFFFF).toString(16).padStart(6, '0');
// Result: '#a3f2c1' (random each time)

// How it works:
// Math.random() → 0 to 1
// * 0xFFFFFF → 0 to 16777215 (max hex color value)
// .toString(16) → convert to hex string
// .padStart(6, '0') → ensure 6 chars (add leading zeros if needed)

// Generate N unique colors for a chart:
const colors = Array.from({ length: 5 }, () => 
 '#' + Math.floor(Math.random() * 0xFFFFFF).toString(16).padStart(6, '0')
);

# ✅ Kill whatever is running on port 3000 (works on Mac/Linux)
kill -9 $(lsof -ti:3000)

# Safer version — shows what you're killing first
lsof -ti:3000 | xargs -I{} sh -c 'echo "Killing PID: {}" && kill -9 {}'

# Windows equivalent (PowerShell):
# Get-Process -Id (Get-NetTCPConnection -LocalPort 3000).OwningProcess | Stop-Process -Force

# Python 3 (built-in, no install needed)
python3 -m http.server 8000
# Serves current directory at http://localhost:8000

# Node.js (if you have npx)
npx serve .

# With CORS headers (useful for local API testing)
python3 -c "
import http.server, socketserver
class Handler(http.server.SimpleHTTPRequestHandler):
 def end_headers(self):
 self.send_header('Access-Control-Allow-Origin', '*')
 super().end_headers()
socketserver.TCPServer(('', 8000), Handler).serve_forever()
"

# Find recently modified files — useful for debugging deployments
find . -mtime -1 -type f -not -path '*/node_modules/*' -not -path '*/.git/*'

# With file sizes
find . -mtime -1 -type f | xargs ls -lh

# Find large files (over 100MB) in current directory
find . -size +100M -type f | xargs ls -lh

# Delete all .log files recursively (with confirmation)
find . -name "*.log" -type f -exec rm -i {} ;