In JavaScript, `document.currentScript` refers to the ```<script>``` element that is currently being processed. This is an essential feature for developers who need to identify or work with the script that's being executed, especially when dealing with inline scripts. However, complications arise when script elements are added dynamically to the DOM via JavaScript. Notably, these dynamically added scripts typically do not have attributes when accessed via `document.currentScript`.

Understanding `document.currentScript`

`document.currentScript` is a read-only property that returns the ```<script>``` element that is currently being processed. This can be either an external script or an inline script. It's particularly useful in inline scripts where you might want to access the script element itself to retrieve data from custom attributes or to execute dynamic operations based on the script's location.

The Issue with Dynamically Added Script Elements

When script elements are dynamically added, say via JavaScript using methods like `document.createElement('script')` and appended to the DOM using `appendChild` or similar methods, `document.currentScript` will not behave as expected. More specifically, when the script is executed, `document.currentScript` returns `null` in many cases, as the dynamic script execution doesn't correspond directly to when scripts are statically parsed and executed.

Why Attributes Might Be Missing

Let's delve into why dynamically added scripts can lead to `document.currentScript` having no attributes:

1. No Static Parsing: When scripts are parsed from the HTML, the browser recognizes and tracks the script elements as they load and execute. However, for dynamically added scripts, this static parsing phase doesn't occur.
2. Execution Contexts: Dynamic scripts often are executed asynchronously, even if appended to the DOM without the `async` attribute. This asynchronous execution results in `document.currentScript` being unreliable because it becomes challenging to identify the execution context accurately.
3. Loading Order: The loading and execution order of dynamically added scripts can vary greatly, especially with network-stated elements like external scripts. Hence, `document.currentScript` might not be set at all or at the wrong time.
4. Caching Mechanism: For browser optimizations, previously fetched scripts might be cached, causing the script’s execution context to differ when fetched from cache compared to when first loaded.

Code Example

Consider this JavaScript snippet:

• Closure Approach: Encapsulate the script's logic within a closure that references known properties or attributes.
• Global Variables: Although typically discouraged, global variables can be used to track the executing context for dynamically added scripts.
• Callback Functions: Specify callback functions that have access to the necessary data and execution context.