Classes And Modules — Part 1 MCQs with Explanations

The behaviour of the instance of a class is defined by the class and is shared by all instances.

The ‘this’ keyword is used to refer to the object through which the properties or methods were invoked. This use of ‘this’ is a fundamental characteristic of the methods of any class.

The result is true: the constructor property specifies the class.

The basic difference between JavaScript and Java is that the functions are values, and there is no hard distinction between methods and fields.

JavaScript’s prototype-based inheritance mechanism is dynamic: an object inherits properties from its prototype, even if the prototype changes after the object is created. This means that we can augment JavaScript classes simply by adding new methods to their prototype objects.

The JSON format is intended for serialization of data structures and can handle JavaScript primitive values, arrays, and plain objects. It does not know about classes, and when serializing an object, it ignores the object’s prototype and constructor. If you call JSON.stringify() on a Range or Complex object, for example, it returns a string like {“from”:1, “to”:3} or {“r”:1, “i”:-1}.

Instances of B inherit all the instance methods of A. The class B can define its own instance methods, some of which may override methods of the same name defined by class A.

The subclass B inherits the prototype of the class A.

When used to define new properties, any attributes you omit default to false. Therefore, both Object.defineProperty() and Object.defineProperties() can be used to create and modify the attributes.

The four kinds of class members are Instance fields, Instance methods, Class fields, Class methods.

In JavaScript, there are three different objects involved inany class definition, and the properties of these three objects act like different kinds of class members namely, Constructor object, Prototype object, and Instance object.

The properties of the prototype object are inhertied by all instances of the class, and properties whose values are functions behave like instance methods of the class.

The variable properties are usually variables that are used internally in the objects methods, but can also be globally visible variables that are used through the page.

The JavaScript RegExp class represents regular expressions, and both string and RegExp define methods that use regular expressions.

The above code snippet returns a complex number that is the complex conjugate of this one.

It is possible to add methods to Object.prototype , making them available on all objects. This is not recommended, however, because prior to ECMAScript5, there is no way to make these add-on methods nonenumerable, and if you add properties to Object.prototype , those properties will be reported by all for/in loops.

It is implementation-dependent whether classes defined by the host environment (such as the web browser) can be augmented using Object.prototype . In many web browsers, for example, you can add methods to HTMLElement.prototype and those methods will be inherited by the objects that represent the HTML tags in the current document.

One can refresh the webpage in JavaScript by using location.reload .

Both the Dojo toolkit and Google’s Closure library define provide() and require() functions for declaring and loading modules.

Generally, the various modules are allowed to run in the pristine (or near pristine) environment that it expects. The modules should minimize the number of global symbols they define – ideally, no module should define more than one.

The sets object is the namespace for the module, and we define each of the set classes as a property of this object.

A programmer can import frequently used values into the global namespace. A programmer who was going to make frequent use of the Set class from the sets namespace might import the class like that.

The scope of a function can be used as a private namespace for a module. Therefore, the scope of a function is called a module function .

Modules that have more than one item in their API can return a namespace object.

Frameworks that define module loading systems may have other methods of exporting a module’s API. There may be a provides() function for modules to register their API, or an exports object into which modules must store their API.

Rather than importing individual classes, a programmer might import the entire module to the global namespace.

The properties() method is a non-enumerable method.

One way for a module to avoid the creation of global variables is to use an object as its namespace. Instead of defining global functions and variables, it stores the functions and values as properties of an object (which may be referenced to a global variable).

The ‘S’ is a special metacharacter that matches the end of a string.

The given pattern is applied on the text given in the paranthesis.

The [^…] character class is used to match or draw any one character not between the brackets.

We should always be careful while using * and ? as repetition characters as they may match zero instances of whatever precedes them, they are allowed to match nothing.

Using non greedy repetition may not always produce the results you expect. /a+?b/ matches the letter b preceded by the fewest number of a’s possible.

The subexpression /java(script)?/ matches “java” followed by the optional “script”.

When a regular expression is successfullyy matched against a target string, it is possible to extract the portions of the target string that matched any particular paranthesized subpattern. The essential purpose of parantheses in regular expressions is to define subpatterns within the complete pattern.

The replace() method performs a search-and-replace operation. It takes a regular expression as its first argument and a replacement string as its second argument.

The split() method can take regular expressions as its arguments. The split() method generally breaks the string on which it is called into an array of substrings, using the argument as a separator.

The Crockford’s subset does not include the with and continue statements or the eval() function. It defines functions using function definition expressions only and does not include the function definition statement.

The subset does not include the comma operator, the bitwise operators, or the ++ and — operators. It also disallows == and != because of the type conversion they perform, requiring use of === and !== instead.

Each subset is coupled with a static verifier that parses code to ensure that it conforms to the subset.