Caching And Debugging — Part 1 MCQs with Explanations

Normally when you reference variables in other scopes— at the global level, in other namespaces, and so on—the interpreter needs to traverse the stack to get to the variable.

The attribute location belongs to the document element.

If you reference document.location from within an object, the interpreter will need to go from the function that references the variable, up out of the namespace to the global window scope, down to the document scope, and get the location value.

The locally scoped variables are created to cache the reference to document.location.

Once the startTimeLogging() method is called, run the code to test.

During the traversal in the stack manner, after going to the namespace, it goes to the Window.

During the traversal in the stack manner, after going to the window, it goes no where.

When you create a locally scoped variable for caching the reference, the traversal reverses in the forward direction and thus, after going to the namespace, it goes to the function.

In order to stop capturing the ad hoc timing for referencing uncached document.location, we call the method stopTimeLogging().

When you create a locally scoped variable for caching the reference, the traversal reverses in the forward direction and thus, after going to the location, it goes no where.

In Simple mode it mostly performs like most other minifiers, removing whitespace, line breaks, and comments.

A closure compiler UI is a web application.

The closure compiler is highly beneficial in terms of : 1. Efficiency: The Closure Compiler reduces the size of your JavaScript files and makes them more efficient, helping your application to load faster and reducing your bandwidth needs. 2. Code checking: The Closure Compiler provides warnings for illegal JavaScript and warnings for potentially dangerous operations, helping you to produce JavaScript that is less buggy and easier to maintain.

The Closure Compiler reduces the size of your JavaScript files and makes them more efficient, helping your application to load faster and reducing your bandwidth needs.

You can use the Closure Compiler as: 1. An open source Java application that you can run from the command line. 2. A simple web application. 3. A RESTful API.

Closure Templates are a templating system for dynamically generating HTML in both Java and JavaScript. Because the language was apparently referred to as “Soy” internal to Google, and “Soy” remains in some of the documentation and classes, sometimes Closure Templates are referred to as “Soy Templates”.

The Closure Compiler provides warnings for illegal JavaScript and warnings for potentially dangerous operations, helping you to produce JavaScript that is less buggy and easier to maintain.

The Closure Compiler is a tool for making JavaScript download and run faster. It is a true compiler for JavaScript. Instead of compiling from a source language to machine code, it compiles from JavaScript to better JavaScript. It parses your JavaScript, analyzes it, removes dead code and rewrites and minimizes what’s left. It also checks syntax, variable references, and types, and warns about common JavaScript pitfalls.

One of the fundamental features of client-side JavaScript is that it is single-threaded: a browser will never run two event handlers at the same time, and it will never trigger a timer while an event handler is running, for example.

JavaScript has two synchronous load() and require().

The client-side JavaScript functions must not run too long: otherwise they will tie up the event loop and the web browser will become unresponsive to user input.

The Worker object: this is what a worker looks like from the outside, to the thread that creates it.

The WorkerGlobalScope is the global object for a new worker, and it is what a worker thread looks like, on the inside, to itself.

To create a new worker, just use the Worker() constructor, passing a URL that specifies the JavaScript code that the worker is to run.

If you specify an absolute URL, it must have the same origin (same protocol, host, and port) as that containing document.

Once you have a Worker object, you can send data to it with postMessage(). The value you pass to postMessage() will be cloned, and the resulting copy will be delivered to the worker via a message event:

You can use onmessage and onerror properties if you want to manage multiple event handlers.

The close() function allows a worker to terminate itself, and it is similar in effect to the terminate() method of a Worker object.

A Blob is an opaque reference to, or handle for, a chunk of data. The name comes from SQL databases, where it means “Binary Large Object.” In JavaScript, Blobs often represent binary data, and they can be large, but neither is required: a Blob could also represent the contents of a small text file.

Blobs are opaque: all you can do with them directly is determine their size in bytes, ask for their MIME type, and chop them up into smaller Blobs.

The web browser can store Blobs in memory or on disk, and Blobs can represent really enormous chunks of data (such as video files) that are too large to fit in main memory without first being broken into smaller pieces with slice().

The web browser can store Blobs in memory or on disk, and Blobs can represent really enormous chunks of data (such as video files) that are too large to fit in main memory without first being broken into smaller pieces with slice().

Blobs are supported by the structured clone algorithm, which means that you can obtain one from another window or thread via the message event.

Blobs can be retrieved fro client-side databases.

You can create your own blobs, using a BlobBuilder object to build them out of strings, ArrayBuffer objects, and other Blobs.

The client-side JavaScript File object is a subtype of Blob: a File is just a Blob of data with a name and a modification date.

You can upload a Blob to a server by passing it to the send() method of an XMLHttpRequest object.

Create a Blob URL with the function createObjectURL(). At the time of this writing, the draft specification and Firefox 4 put this function in a global object named URL, and Chrome and Webkit prefix that new global, calling it webkitURL.

Memory leaks occur when we are developing client-side reusable scripting objects.

The central concept of JavaScript memory management is a concept of reachability. 1. A distinguished set of objects are assumed to be reachable: these are known as the roots. Typically, these include all the objects referenced from anywhere in the call stack (that is, all local variables and parameters in the functions currently being invoked), and any global variables. 2. Objects are kept in memory while they are accessible from roots through a reference or a chain of references.