DOCSEARCHbyAlgolia
Submit Docs

Deore's Technical Notes

website·Indexed 31 days ago

https://deore.me

A collection of technical documentation and learning notes covering front-end development, including JavaScript internals (Event Loop, Promises/A+, Prototypes), Web APIs (MutationObserver, Web Components), HTTP protocols, and a specialized series on the pictographic etymological evolution of the English alphabet.

Tokens
70.2K
Snippets
255
Records
502
Agent score
53%

What's inside Deore

  1. Overview of HTTP Protocol Characteristics

    HTTP (HyperText Transfer Protocol) is a widely used network protocol defining the format and specifications for information exchange between clients and servers. Its core characteristics include:

    • Client-Server Model: Follows a classic request-response pattern.
    • Stateless: The protocol itself does not maintain state, though state can be managed using mechanisms like Cookies and Sessions. It supports any data type via the Content-Type header.
    • Connectionless: Traditionally closes the connection after each request (though HTTP/1.1 introduced persistent connections by default).
    • Extensible: Functionality can be extended via HTTP headers, new status codes, or custom request methods.
    • Reliable Transport: Built on TCP/IP, ensuring reliable data delivery.

  2. Overview of the JavaScript Reflect API

    The Reflect object is a built-in JavaScript object that provides methods for intercepting JavaScript operations. It allows developers to dynamically check, modify, and call object properties and methods at runtime without knowing the object's exact structure. Unlike Object, Reflect is not a constructor and cannot be used to create new objects. While it provides flexibility and extensibility, it can potentially break encapsulation and introduce performance overhead.

  3. Overview of Git Stash for temporary work storage

    Git Stash allows you to temporarily shelf (stash) uncommitted changes in your working directory. This reverts the working directory to a clean state (matching the HEAD commit), enabling you to switch contexts—such as addressing an urgent bug fix—without committing incomplete work. You can later restore these changes to continue where you left off.

  4. Overview of the JavaScript Reflect API

    The Reflect object is a built-in JavaScript object that provides methods for intercepting JavaScript operations. It allows developers to dynamically inspect, modify, and call object properties and methods at runtime without knowing the object's exact structure. Unlike Object, Reflect is not a constructor and cannot be used to create new objects.

  5. Overview of the English Alphabet's Evolution

    The English alphabet is the result of a long evolutionary process spanning thousands of years. Its lineage can be traced through several key stages: Sumerian Cuneiform (c. 3200 BC), Ancient Egyptian Hieroglyphs (c. 3000 BC), Proto-Sinaitic/Ancient Semitic (c. 2000 BC), Phoenician (c. 1500 BC), Greek (c. 1100 BC), Etruscan (c. 7th century BC), Latin (c. 7th-6th century BC), and finally the modern English alphabet (c. 1500 AD to present).

  6. Overview of Git Stash for temporary work storage

    Git Stash allows you to temporarily shelf (stash) uncommitted changes in your working directory. This returns the working directory to a clean state (matching the HEAD commit), enabling you to switch branches or handle urgent tasks without committing incomplete work. You can later restore these changes to continue where you left off.

  7. Overview of HTTP Protocol Characteristics

    HTTP (HyperText Transfer Protocol) is a client-server protocol used for exchanging information over the internet. Its core characteristics include:

    • Client-Server Model: Clients send requests and servers return responses.
    • Stateless: Each request is independent. State is maintained via external mechanisms like Cookies and Sessions.
    • Connectionless: Traditionally, connections are closed after a request (though HTTP/1.1 introduced persistent connections).
    • Extensible: Functionality can be expanded via HTTP headers (e.g., custom status codes or request methods).
    • Reliable Transport: Built on TCP/IP, ensuring reliable data delivery.

  8. Overview of Web Components technologies

    Web Components is a browser-native componentization suite that allows the creation of reusable custom elements without external modules. It consists of three primary technologies:

    1. Custom Elements: APIs to define new HTML elements.
    2. Shadow DOM: A way to encapsulate a DOM tree, keeping styles and scripts private and preventing conflicts with the main document.
    3. HTML Templates: The <template> and <slot> elements used to define reusable markup that is not rendered until instantiated.

  9. Etymology of words related to boundaries and borders

    The letter 'b' is associated with the concept of boundaries or frames.

    Examples:

    • bay: b (boundary) + ay
    • border: b (boundary) + order (command/management)
    • bound: b (boundary) + round (surround)
    • board: b (frame) + hard (stiff/hard wood)

  10. Analyze the root 'ele' (observation and elements)

    The root ele represents 'eyes' and the symmetry of the face, meaning 'to see' or 'observe'. In Greek philosophy, this relates to observing the basic components of the objective world (water, earth, air, fire), leading to the concept of 'elements'.
    element: ele (observe) + ment (process) -> basic component/principle
elementary: element + ary -> basic/primary
elemental: element + al -> relating to the basic elements

  11. Understand the pictographic origins of the letter B

    The letter 'B' is analyzed as a pictographic representation of various shapes and concepts, which helps explain the etymology of English words. These include shapes like bed frames, bags, brooms, thumbs, fists, and spherical/expanded objects.

  12. Intercept object operations using Proxy and Reflect

    The Proxy object allows you to define custom behavior for fundamental operations (like property lookup or assignment). Using Reflect methods inside a Proxy handler is a best practice to maintain the default behavior of the operation while adding custom logic.
    const target = {
  message: 'Hello, world!'
};

const handler = {
  get(target, prop, receiver) {
    if (prop === 'message') {
      return `The proxy says: ${Reflect.get(target, prop, receiver)}`;
    }
    return Reflect.get(target, prop, receiver);
  }
};

const proxy = new Proxy(target, handler);

console.log(proxy.message); // 输出: The proxy says: Hello, world!
console.log(proxy.nonExistentProperty); // 输出: undefined