Intermediate code explainers

typescript

type NestedArray<T> = Array<T | NestedArray<T>>;
 
function flatten<T>(input: NestedArray<T>): T[] {
  const result: T[] = [];

Recursively flattening nested arrays in TypeScript

recursion recursive-types generics

Intermediate 7 steps

java

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;

Breadth-first search on an adjacency-list graph

graph-traversal bfs adjacency-list

Intermediate 7 steps

javascript

function flatten(arr) {
  const result = [];
  for (const item of arr) {
    if (Array.isArray(item)) {

Flattening nested arrays with recursion

recursion arrays reduce

Intermediate 7 steps

ruby

class LinkedList
  include Enumerable
 
  Node = Struct.new(:value, :next_node)

Building an enumerable linked list in Ruby

linked-list enumerable data-structures

Intermediate 7 steps

javascript

function getCityName(user) {
  return user?.address?.city ?? "Unknown city";
}

Optional chaining and nullish coalescing in JS

optional-chaining nullish-coalescing defensive-coding

Intermediate 5 steps

typescript

class LRUCache<K, V> {
  private readonly capacity: number;
  private readonly map: Map<K, V>;

Building an LRU cache on a JS Map

caching data-structures generics

Intermediate 8 steps

ruby

module FileResource
  # Opens a file, yields it to the caller, and guarantees the
  # handle is closed even if the block raises an exception.
  def self.open(path, mode = "r")

Guaranteeing cleanup with begin/ensure in Ruby

resource-management exception-safety blocks

Intermediate 8 steps

rust

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

A worker thread driven by Rust channels

concurrency message-passing channels

Intermediate 8 steps

java

public final class Quicksort {
 
    private Quicksort() {
    }

Quicksort with Lomuto partitioning in Java

recursion divide-and-conquer in-place

Intermediate 7 steps

javascript

function delegate(root, eventType, selector, handler) {
  const listener = (event) => {
    let node = event.target;
    while (node && node !== root) {

Event delegation with a clean teardown

event-delegation dom closures

Intermediate 8 steps