DOCSEARCHbyAlgolia
Submit Docs

docs-go Knowledge Base

website·Indexed 31 days ago

https://docs-go.vercel.app

A personal technical knowledge base covering frontend development, Linux system administration, and mobile app development. Includes detailed guides on JavaScript (closures, garbage collection, event loops), React components, Webpack, Flutter, and H5 mobile optimization. Also features Linux tutorials on package managers, directory structures, and shell commands, as well as specific guides for WeChat server-side development and JSBridge.

Tokens
236K
Snippets
876
Records
1.7K
Agent score
72%

What's inside docs-go

  1. Overview of Redis features and data structures

    Redis is an open-source (BSD licensed), in-memory data structure store used as a database, cache, and message broker. It is written in C and uses a key-value data model. Key features include high speed (O(1) time complexity for lookups, similar to a HashMap), persistence, and the ability to set expiration times on keys. Supported data structures include strings, lists, sets, sorted sets, and hashes.

  2. Overview of JavaScript Arrays

    Arrays in JavaScript are ordered collections of values where elements are accessed using zero-based numerical indices. Unlike objects, which have unordered property names, arrays use numbers as lookup keys. JavaScript does not have true associative arrays; objects are used to implement that functionality.

  3. Overview of PM2 Process Manager

    PM2 is a production process manager for Node.js applications that provides the following core capabilities:

    • Process Daemonization: Automatically restarts applications if the system crashes.
    • Cluster Mode: Starts multiple processes to fully utilize multi-core CPUs and memory.
    • Integrated Logging: Built-in functionality for recording and viewing application logs.

  5. Overview of JavaScript Framework Design Patterns

    JavaScript frameworks and libraries can be categorized into five primary architectural patterns based on their core orientation:

    1. Namespace-oriented: Libraries focused on providing a set of utilities under a specific namespace.
    2. Class Factory-oriented: Frameworks where modules are derived from a class factory (e.g., Prototype.js).
    3. Selector-oriented: Frameworks centered around a selector engine that returns a special array-like object for bulk operations (e.g., jQuery).
    4. Loader-oriented: Frameworks composed of multiple files linked by a module loader following a fixed rule (e.g., AMD).
    5. *Layered Architecture (MV / MVVM)**: Frameworks with clear architectural layering. MVVM frameworks (e.g., Angular, Knockout, Vue) replace manual DOM manipulation with declarative data binding.

  6. Overview of the GitFlow workflow

    GitFlow is a strict branching model where each branch has a specific role. It ensures that the master branch is always deployable and reduces the risk of major accidents. However, it is more complex, violates the 'short-lived branch' principle, and is less friendly to Continuous Deployment (CD) or monorepos.

  7. Overview of React Fiber architecture

    Fiber is a reimplementation of React's core algorithm designed to solve UI lag (jank) caused by long-running synchronous rendering tasks that block the main thread.

    Fiber transforms the Virtual DOM tree into a Fiber tree where each node has child, sibling, and return pointers. This allows React to use a depth-first traversal to break rendering work into small chunks that can be paused and resumed, ensuring the main thread remains responsive.

  8. Overview of JavaScript Promises

    A Promise is a solution for handling asynchronous operations, making async code appear more synchronous to improve readability and maintainability compared to traditional callbacks.

    Promise States:

    • pending: Initial state, neither fulfilled nor rejected.
    • fulfilled: The operation completed successfully.
    • rejected: The operation failed.

    State Transition: A Promise can only transition from pending to either fulfilled or rejected. Once a state is set, it cannot be changed.

  9. Overview of React state management library ecosystem

    The React ecosystem features several state management libraries evolving over time. Early dominant libraries include Redux, MobX, and Recoil (developed by Facebook). More recent alternatives include:

    • Zustand: A popular Hooks-based library.
    • xState: Based on state machine implementations.
    • Valtio: Built into umi-max.
    • Jotai: Inspired by Recoil.

  10. Overview of TypeScript Utility Types

    TypeScript provides several built-in utility types to transform existing types:

    • Partial<T>: Makes all properties in T optional.
    • Required<T>: Makes all properties in T required.
    • Readonly<T>: Makes all properties in T read-only.
    • Exclude<T, U>: Excludes types from T that are present in U.
    • Extract<T, U>: Extracts types from T that are also present in U.
    • Omit<T, K>: Removes specific keys K from T.
    • ReturnType<T>: Extracts the return type of a function type T.

  11. Overview of the five stages of computer evolution

    The evolution of computers is categorized into five distinct stages based on the hardware technology used for processing:

    1. Vacuum Tube Computers (1946–1957): Characterized by low integration, large physical size, high power consumption, slow speeds, and complex manual wiring for programming (e.g., ENIAC).
    2. Transistor Computers (1957–1964): Introduced by Bell Labs; featured higher integration, smaller size, lower power consumption, and faster speeds compared to vacuum tubes.
    3. Integrated Circuit (IC) Computers (1964–1980): Developed by Texas Instruments; further reduced size and power consumption while increasing calculation speed.
    4. Very Large Scale Integration (VLSI) Computers (1980–Present): Chips integrate millions of transistors, leading to faster speeds, smaller footprints, lower costs, and wider application.
    5. Future Computers: Research focuses on Biological Computers (using protein molecules) and Quantum Computers (based on quantum mechanics).

  12. Overview of HTTP Protocol Evolution

    The HTTP protocol has evolved through several versions to improve flexibility, performance, and security:

    • HTTP/0.9: A simple text-based protocol supporting only GET requests; connections were closed immediately after the response.
    • HTTP/1.0: Introduced HEAD and POST methods, response status codes, protocol versioning, HTTP Headers, and support for non-text data.
    • HTTP/1.1: The first formal standard (RFC 2616). Introduced PUT and DELETE methods, cache management, persistent connections (Keep-Alive), chunked transfer encoding for large files, and mandatory Host headers for virtual hosting.
    • HTTP/2: Based on Google's SPDY. Introduced a binary protocol, multiplexing (multiple concurrent requests), header compression, server push, and a strong practical requirement for encryption.
    • HTTP/3: Based on Google's QUIC protocol, focusing on further performance improvements and reducing connection latency.