API reference manual

Python str methods for manipulating text — splitting, replacing, searching, formatting and transforming strings.

Python list methods — mutable ordered sequences for storing and manipulating collections.

Python dict methods — mutable mapping of hashable keys to values.

Python built-in numeric functions — abs, round, min, max, sum, pow, divmod and conversions.

JavaScript Array methods for transforming, searching and mutating arrays.

JavaScript String methods for splitting, replacing, matching and transforming text.

JavaScript Math object — constants and functions for numbers.

JavaScript Object static methods for keys, values, merging and freezing.

JavaScript Date methods for reading and formatting dates and times.

JavaScript Promise methods for asynchronous programming — combining, racing, resolving, and handling async values.

TypeScript built-in utility types for transforming and combining types.

TypeScript type guards for narrowing types at runtime.

TypeScript decorators — special declarations for annotating classes and their members (experimental).

Go strings package — functions for manipulating UTF-8 strings.

Go fmt package — formatted I/O with C-style verbs.

Go strconv package — conversions between strings and basic types.

Go sort package — sorting slices and custom collections.

Java String methods — immutable character sequences.

Java ArrayList — resizable-array implementation of the List interface.

Java HashMap — hash-table-based implementation of the Map interface.

Java Math class — methods for basic numeric operations.

SQL string functions for concatenation, extraction and transformation.

SQL aggregate functions for summarizing grouped rows.

SQL date and time functions for current values, arithmetic and formatting.

SQL window functions for computations across rows related to the current row.

Rust's Vec<T> — a growable, heap-allocated contiguous sequence. The default collection for owned lists.

Rust's String — a growable, owned UTF-8 encoded string type, heap-allocated and mutable.

Rust's HashMap<K, V> — a hash map with quadratic probing and SipHash by default.

C++ std::string — a contiguous, growable sequence of chars with a rich member-function interface.

C++ std::vector — a contiguous, dynamically-resizable array with O(1) random access.

C++ std::map — an ordered associative container of key-value pairs, implemented as a red-black tree.

C# String — an immutable sequence of UTF-16 code units, the primary text type in .NET.

C# List<T> — a strongly-typed, dynamically-resizable list backed by an internal array.

C# LINQ — a set of extension methods for querying IEnumerable<T> sequences with a declarative syntax.

PHP's built-in string functions for measuring, searching, slicing, replacing and transforming strings.

PHP's built-in array functions — PHP arrays serve as both lists and ordered maps.

PHP Data Objects (PDO) — a uniform, object-oriented interface for accessing databases in PHP.

Ruby's String — a mutable sequence of bytes holding characters, with a rich set of methods.

Ruby's Array — an ordered, integer-indexed collection of any objects, with rich functional methods.

Ruby's Hash — a dictionary mapping unique keys to values, preserving insertion order.

Swift's String — a value type representing a sequence of Unicode scalar values (extended grapheme clusters).

Swift's Array<T> — an ordered, random-access collection of elements, backed by contiguous storage.

Swift's Dictionary<K, V> — a collection of unique keys mapped to values, with O(1) average lookup.

Kotlin's String — an immutable sequence of UTF-16 code units, enhanced with extension functions.

Kotlin's List<T> — an immutable ordered collection; MutableList<T> adds in-place mutation.

Kotlin's Map<K, V> — an immutable key-value collection; MutableMap<K, V> adds mutation.

R's base vector functions — vectors are the fundamental data structure in R, holding elements of one type.

R's data.frame — a tabular structure of rows and columns, the workhorse of base R data analysis.

stringr — a tidyverse package providing a consistent, pipe-friendly API for string manipulation.

Bash parameter expansion — built-in string operations performed on shell variables without external tools.

Bash indexed arrays — one-dimensional, sparse, integer-indexed collections of strings.

Bash test expressions — file, string and numeric comparisons used in [ ] and [[ ]] conditionals.

Angular core APIs — the @Component decorator and lifecycle, HttpClient for HTTP, and the Router for navigation.

Vue 3 core APIs — reactivity primitives, component definition, and the composables convention.

jQuery core APIs — selector and engine, AJAX helpers, and DOM manipulation methods.

Bootstrap 5 component JavaScript API — programmatic control of modal, tooltip, popover, and dropdown.

HTML5 browser APIs — Canvas 2D drawing, Web Storage for client-side key/value data, and Geolocation.

Modern CSS properties (flexbox, grid, transforms) and built-in functions (calc, var, gradients).

Sass built-in functions for color manipulation and the @mixin/@include/@extend control directives.

Tailwind CSS configuration — customizing the theme, controlling content sources, and dark mode strategy.

jQuery UI APIs — interaction behaviors (draggable, droppable, sortable) and UI widgets (accordion, datepicker, dialog, tabs).

jQuery Mobile APIs — page navigation/transition system and touch-optimized widgets (listview, navbar, popup).

Chart.js APIs — the Chart constructor and lifecycle, plus controller-specific config for bar, line, and pie charts.

Apache ECharts APIs — instance lifecycle (init/setOption/resize) and the option object driving series, axes, and tooltip.

AngularJS (1.x) core APIs — module definition with controllers/services/directives, the $scope digest loop, and $http for XHR.

Dockerfile instructions for building reproducible container images layer by layer.

Docker command-line interface for building, shipping and running containers and images.

kubectl command-line tool for deploying and inspecting applications on a Kubernetes cluster.

YAML manifest fields shared by every Kubernetes resource object.

MongoDB collection methods for inserting, querying, updating and aggregating documents.

MongoDB query and aggregation operators used to filter, transform and group documents.

MySQL SELECT statement clauses for querying and combining rows from one or more tables.

MySQL Data Definition Language for creating and altering tables, indexes and constraints.

PostgreSQL SELECT features including window functions, CTEs, LATERAL joins and RETURNING.

PostgreSQL JSONB functions and operators for storing, querying and transforming JSON documents.

Redis String commands for storing, reading and atomically updating single values.

Redis collection data type commands: lists, hashes, sets and sorted sets.

Nginx configuration directives used to define virtual servers, locations and proxying behavior.

Built-in Nginx variables exposing request and connection properties usable in directives.

Core Linux file and directory commands for listing, copying, moving, finding and changing permissions.

Linux text-processing pipelines for filtering, transforming and summarizing streamed text.

SQLite SQL dialect for creating tables, inserting rows, querying data and inspecting schema metadata via PRAGMA.

sqlite3 command-line shell dot-commands for opening databases, dumping data and inspecting schemas.

Node.js fs module for filesystem access including reading, writing, listing and inspecting paths.

Node.js http module for building HTTP servers and issuing HTTP clients requests.

C standard input/output library providing file operations, formatted read/write and other core functions.

cURL command-line tool common options for sending HTTP requests and transferring data.

HTTP protocol request methods and status code semantics defining client-server interaction rules.

JSON (JavaScript Object Notation) data format syntax for data interchange.

Regular expression pattern syntax for text matching, searching and replacing.

CSS selectors and properties reference for precisely targeting and styling document elements.

HTML elements and attributes reference for building web page structure and semantic content.

SVG shape and path element reference for drawing vector graphics in web pages.

XML syntax and structure reference for describing extensible markup language building blocks.

YAML data structures and syntax reference for writing human-readable configuration and data serialization.

Markdown syntax reference for writing rich text in plain text format that converts to HTML.

GraphQL query language reference for declaratively querying and operating on API data.

Django ORM provides a powerful database abstraction layer; Views handle HTTP requests and template responses.

FastAPI builds high-performance APIs based on type annotations, with automatic validation, dependency injection and OpenAPI docs.

Flask is a lightweight WSGI framework, managing routing, requests and responses via application and request contexts.

NumPy provides high-performance multidimensional ndarray and vectorized numerical computing capabilities.

Pandas provides DataFrame and Series, supporting reading, cleaning, transforming and analyzing tabular data.

Matplotlib.pyplot provides a MATLAB-like plotting interface that generates various static charts.

OpenCV (cv2) provides image read/write, color conversion, filtering, edge detection and video capture computer vision APIs.

PyTorch provides dynamic computation graphs, tensor operations and autograd, widely used for deep learning modeling and training.

tf.keras is TensorFlow's high-level API, providing layers, models, training and data pipeline abstractions.

scikit-learn provides a unified fit/predict API covering preprocessing, classification, regression and model evaluation.

Combines NLTK's classic text processing capabilities with Hugging Face Transformers' pretrained model capabilities.

Dart core library providing basic types, collections, async and class definitions as core APIs.

Delphi RTL SysUtils unit providing string, formatting, file and type conversion base functions.

Elixir Kernel and Enum modules providing IO, string, collection and process-related functions.

Fortran intrinsic functions and statements covering IO, array operations and numerical computing.

Haskell Prelude standard functions and type classes imported by default.

Lua standard library providing string, table, generic functions and module loading APIs.

MATLAB built-in functions covering display, matrix operations, numerical computing and plotting.

Perl built-in functions covering IO, strings, lists, files and definition checks.

Scala standard library covering collections, Option, Future and functional syntax structures.

Solidity global variables and members covering transaction context, assertions, transfers and events.

Visual Basic built-in functions and statements covering IO, strings, type conversion and control flow.

Vim Ex commands and built-in functions covering help, files, substitution, buffers and scripting.

Git version control system common command reference, covering repository initialization, cloning, committing, branching, merging, rebasing and remote repository management.

Memcached protocol command reference, covering storage, retrieval, modification, compare-and-swap and statistics core operations.

React Hooks API reference, covering state, effects, context, reducer, ref, memoization and layout effect core hooks.

redis-cli command-line tool reference, covering connection, testing, key-value operations, expiration management and server info queries.

WebAssembly JavaScript API reference, covering module compilation, instantiation, validation, memory, tables and streaming loading core interfaces.

Julia's dense multidimensional array type — the central data structure for numerical and scientific computing, with element-wise broadcasting and rich indexing.

Core x86-64 instructions for data movement, arithmetic, control flow, and Linux system calls (Intel/NASM syntax).

The erlang module's core concurrency primitives — spawn, message sending, linking, and monitoring for building fault-tolerant systems.