Evaluation

The following points summarize what you should learn from reading this book (and studying the code examples). Read each summary and return to the topic in the book if you don't understand what it says.

• Objects consist of named properties that store values.
• Most things in JavaScript behave like objects. Complex values ​​are objects, while primitive values ​​can be treated like objects. This is why you might hear people say that everything in JavaScript is an object.
• Create an object by calling a constructor using the new keyword or using a shorthand literal expression.
• Constructors are objects (Function() objects), so in JavaScript, objects create objects.
• JavaScript provides nine native constructors: Object(), Array(), String(), Number() , Boolean(), Function() , Date(), RegExp() and Error() . The String(), Number() and Boolean() constructors serve a dual purpose: providing a) a primitive value and b) an object wrapper when needed, so that primitive values ​​can work like objects.
• Valuesnull, undefined, "string", 10, true and false They are all primitive values ​​and have no object properties unless they are treated like objects.
• When>Object(), Array(), String(), Number(), Boolean( ), Function(), Date (), RegExp() and Error() constructors use The new keyword is called to create an object called a "complex object" or "reference object". 李>
• "string", 10, true, and false have no object properties in their raw forms until they are used as objects; JavaScript then creates temporary wrapper objects behind the scenes so that the values ​​can behave like objects.
• The original value is stored by value and copied literally when copied. Complex object values, on the other hand, are stored by reference, and when copied, are copied by reference.
• Primitive values ​​are equal to other primitive values ​​when their values ​​are equal, whereas complex objects are equal only when they refer to the same value. That is: when one complex value refers to the same object, two complex values ​​are equal to the other complex value.
• Due to the nature of complex objects and references, JavaScript objects have dynamic properties.
• JavaScript is mutable, which means that native objects and user-defined object properties can be manipulated at any time.
• Getting/setting/updating object properties is done by using dot notation or square bracket notation. Bracket notation is convenient when the object property name you are operating on takes the form of an expression (for example, Array['prototype']['join'].apply()).
• When referencing an object property, a lookup chain will be used to first look at the object referenced by the property. If the attribute does not exist, the attribute is looked up in the constructor prototype attribute. If it's not found there, because the prototype holds an object value and that value is created from the Object() constructor, so in the Object() constructor Find this property on the prototype property (Object).prototype). If the property is not found there, the property is determined to be undefined.
• prototype Lookup chains are how inheritance (aka prototypal inheritance) is designed in JavaScript.
• Due to the object property lookup chain (aka prototypal inheritance), all objects inherit from Object() because the prototype property itself is an Object() Object.
• JavaScript functions are first-class citizens: functions are objects with properties and values.
The
• this keyword, when used inside a function, is a general way to reference the object containing the function.
The value of
• this is determined at runtime based on the context in which the function is called.
• When used in the global scope, the this keyword refers to the global object.
• JavaScript uses functions to create unique scopes.
• JavaScript provides a global scope, and all JavaScript code exists in this scope.
• Functions (especially wrapper functions) create scope chains for parsing variable lookups.
• The scope chain is set based on the way the code is written, not necessarily based on the context in which the function is called. This allows a function to access the scope in which it was originally written, even if the function is called from a different context. This result is called a closure.
• Do not use var Function expressions and variables declared inside the function will become global properties. However, function statements within function scope are still defined in the scope in which they are written.
• Functions and variables declared in the global scope (without var) will become properties of the global object.
• Functions and variables declared in the global scope (using var) become global variables.

---

in conclusion

Thank you for reading!

The above is the detailed content of Evaluation. For more information, please follow other related articles on the PHP Chinese website!