JavaScript ็่ณๆๅๅฅ่่ณๆ็ตๆง
็จๅผ่ช่จ้ฝๅ ทๆ่ณๆ็ตๆง๏ผไฝๅจไธๅ็็จๅผ่ช่จไน้ๆๆไบๅทฎ็ฐใ้่ฃกๅฐๅๅบๅฏไปฅๅจ JavaScript ไธญไฝฟ็จ็่ณๆ็ตๆง๏ผไปฅๅๅฎๅ็็นๆง๏ผๅฎๅๅฏไปฅ็จไพๆงๆๅ ถไป็่ณๆ็ตๆงใๅฆๆๅฏไปฅ็่ฉฑ๏ผๆๆจ็คบ่ๅ ถไป่ช่จไธๅ็ๅฐๆนใ
ๅๆ ๅๅฅ
JavaScript ๆฏๅผฑๅๅฅ๏ผไน่ฝ่ชชๆฏๅๆ ็็จๅผ่ช่จใ้ไปฃ่กจไฝ ไธๅฟ ็นๅฅๅฎฃๅ่ฎๆธ็ๅๅฅใ็จๅผๅจ้ไฝๆ๏ผๅๅฅๆ่ชๅ่ฝๆใ้ไนไปฃ่กจไฝ ๅฏไปฅไปฅไธๅ็ๅๅฅไฝฟ็จๅไธๅ่ฎๆธใ
var foo = 42; // foo ็ฎๅๆฏๆธๅญ
var foo = "bar"; // foo ็ฎๅๆฏๅญไธฒ
var foo = true; // foo ็ฎๅๆฏๅธๆๅผ
่ณๆๅๅฅ
ๆๆฐ็ ECMAScript ๆจๆบๅฎ็พฉไบไธ็จฎ่ณๆๅๅฅ๏ผ
ๅๅงๅผ
้คไบ็ฉไปถไปฅๅค็ๆๆๅผ๏ผ้ฝๆฏๅๅงๅฎ็พฉ็ๅผ๏ผๅผๆๅณ่ไธ่ฝ่ขซๆน่ฎ๏ผใไพๅฆ่ C ไธๅ็ๅฐๆน๏ผๅฐฑๆฏๅญไธฒๆฏไธ่ฎ็ใๆๅๅผ็จ้ไบ้กๅ็ๅผ็บ primitive values๏ผๅๅงๅผ๏ผใ
ๅธๆๅๅฅ
ๅธๆ๏ผBoolean๏ผไปฃ่กจไบๆๅ
ฉๅๅผ็้่ผฏๅฏฆ้ซ๏ผtrue ่ falseใ
Null ๅๅฅ
Null ๅๅฅๅชๆไธๅๅผ๏ผnullใ่ซๅ่ฆ null ่ Nullใ
ๆชๅฎ็พฉๅๅฅ
ไธๅๆฒๆ่ขซๅฎ็พฉ็่ฎๆธๆ undefined ๅผใ่ซๅ่ฆ undefined ่ Undefinedใ
ๆธๅญๅๅฅ
ๆ นๆ ECMAScript ๆจๆบ๏ผๆธๅญๅๅฅๅชๆไธ็จฎ๏ผ้็ฒพๅบฆ 64 ไฝๅ
ไบ้ฒๅถๆ ผๅผ IEEE 754 ๅผ๏ผๅจ -(2^53 -1) and 2^53 -1 ไน้็ๆธๅญ๏ผใ่ๆดๆธไธฆๆฒๆๆๅฎ็ๅๅฅใๆธๅญ้คไบ่ฝไปฃ่กจๆตฎ้ปๆธไปฅๅค๏ผ้ๆไธๅ็ฌฆ่ๅผ๏ผ+Infinityใ-InfinityใNaN๏ผnot-a-number๏ผ้ๆธๅญ๏ผใ
่ฆๆชขๆฅๅจ +/-Infinity ๅ
งๅฏ็จ็ๆๅคงๅผๆๆๅฐๅผ๏ผๅฏไปฅ็จ Number.MAX_VALUE ๆ Number.MIN_VALUE ๅธธๆธใๅพ ECMAScript 6 ้ๅง๏ผไนๅฏไปฅ้้ Number.isSafeInteger()ใNumber.MAX_SAFE_INTEGERใNumber.MIN_SAFE_INTEGER ๆชขๆฅๆๆธๅญๆฏๅฆ็บ้็ฒพๅบฆๆตฎ้ปๅผไน้ใBeyond this range, integers in JavaScript are not safe anymore and will be a double-precision floating point approximation of the value.
The number type has only one integer that has two representations: 0 is represented as -0 and +0. ("0" is an alias for +0). In the praxis, this has almost no impact. For example +0 === -0 is true. However, you are able to notice this when you divide by zero:
> 42 / +0
Infinity
> 42 / -0
-Infinity
Although a number often represents only its value, JavaScript provides some binary operators. These can be used to represent several Boolean values within a single number using bit masking. However, this is usually considered a bad practice, since JavaScript offers other means to represent a set of Booleans (like an array of Booleans or an object with Boolean values assigned to named properties). Bit masking also tends to make code more difficult to read, understand, and maintain. It may be necessary to use such techniques in very constrained environments, like when trying to cope with the storage limitation of local storage or in extreme cases when each bit over the network counts. This technique should only be considered when it is the last measure that can be taken to optimize size.
ๅญไธฒๅๅฅ
JavaScript ็ ๅญไธฒๅๅฅ็จไพไปฃ่กจๆๅญ่ณๆใๅฎๆฏไธ็ต 16 ไฝ็ๆชๅฎฃๅใๅ
็ด ใๅผใๆฏๅๅญไธฒ็ๅ
็ด ๏ผๅจๅญไธฒๅ
ง็ไฝๆไธไฝใ็ฌฌไธๅๅ
็ด ไฝๆผ็ดขๅผ็็ฌฌ 0 ไฝ๏ผไธไธๅๅ
็ด ไฝๆผ็ฌฌ 1 ไฝ๏ผไธฆไพๆญค้กๆจใๅญไธฒ็้ทๅบฆ๏ผๆฏๆ่ฉฒๅญไธฒๆๅคๅฐๅ
็ด ใ
่ C ้้ก็่ช่จไธๅ๏ผJavaScript ๅญไธฒๆฏไธ่ฎ็๏ผๆๆๆฏ่ชช็ถๅญไธฒ่ขซๅต้ ๅบไพไปฅๅพ๏ผไฝ ไธๅฏ่ฝไฟฎๆนๅฎใไธ้๏ผๅฏไปฅๅบๆผๆไฝๅไพ็ๅญไธฒ๏ผไพ็ข็ๆฐ็ๅญไธฒใไพๅฆ๏ผ
- ้้ๆ้ธๅฎๅๅญๆฏๆไฝฟ็จ
String.substr()็ๅๅงๅญๅญไธฒใ - ไฝฟ็จ็ด่ฏ้็ฎ็ฌฆ๏ผ
+๏ผๆString.concat()้ฃๆฅๅ ฉๅๅญ็ฌฆไธฒใ
Beware of "stringly-typing" your code!
It can be tempting to use strings to represent complex data. Doing this comes with short-term benefits:
- It is easy to build complex strings with concatenation.
- Strings are easy to debug (what you see printed is always what is in the string).
- Strings are the common denominator of a lot of APIs (input fields, local storage values,
XMLHttpRequestresponses when usingresponseText, etc.) and it can be tempting to only work with strings.
With conventions, it is possible to represent any data structure in a string. This does not make it a good idea. For instance, with a separator, one could emulate a list (while a JavaScript array would be more suitable). Unfortunately, when the separator is used in one of the "list" elements, then, the list is broken. An escape character can be chosen, etc. All of this requires conventions and creates an unnecessary maintenance burden.
Use strings for textual data. When representing complex data, parse strings and use the appropriate abstraction.
Symbol type
Symbols are new to JavaScript in ECMAScript Edition 6. A Symbol is a unique and immutable primitive value and may be used as the key of an Object property (see below). In some programming languages, Symbols are called atoms. You can also compare them to named enumerations (enum) in C. For more details see Symbol and the Symbol object wrapper in JavaScript.
Objects
ไปฅ่ณ่จ็งๅญธ่่จ๏ผ็ฉไปถๆฏๅ่ฝ้้identifierๅ็ ง็ๆๆธๅผ่จๆถ้ซใ
Properties
In JavaScript, objects can be seen as a collection of properties. With the object literal syntax, a limited set of properties are initialized; then properties can be added and removed. Property values can be values of any type, including other objects, which enables building complex data structures. Properties are identified using key values. A key value is either a String or a Symbol value.
There are two types of object properties which have certain attributes: The data property and the accessor property.
Data property
Associates a key with a value and has the following attributes:
| Attribute | Type | Description | Default value |
|---|---|---|---|
| [[Value]] | Any JavaScript type | The value retrieved by a get access of the property. | undefined |
| [[Writable]] | Boolean | If false, the property's [[Value]] can't be changed. |
false |
| [[Enumerable]] | Boolean | If true, the property will be enumerated in for...in loops. See also Enumerability and ownership of properties |
false |
| [[Configurable]] | Boolean | If false, the property can't be deleted and attributes other than [[Value]] and [[Writable]] can't be changed. |
false |
| Attribute | Type | Description |
|---|---|---|
| Read-only | Boolean | Reversed state of the ES5 [[Writable]] attribute. |
| DontEnum | Boolean | Reversed state of the ES5 [[Enumerable]] attribute. |
| DontDelete | Boolean | Reversed state of the ES5 [[Configurable]] attribute. |
Accessor property
Associates a key with one or two accessor functions (get and set) to retrieve or store a value and has the following attributes:
| Attribute | Type | Description | Default value |
|---|---|---|---|
| [[Get]] | Function object or undefined | The function is called with an empty argument list and retrieves the property value whenever a get access to the value is performed. See also get. |
undefined |
| [[Set]] | Function object or undefined | The function is called with an argument that contains the assigned value and is executed whenever a specified property is attempted to be changed. See also set. |
undefined |
| [[Enumerable]] | Boolean | If true, the property will be enumerated in for...in loops. |
false |
| [[Configurable]] | Boolean | If false, the property can't be deleted and can't be changed to a data property. |
false |
ๅ่จป๏ผ Attribute is usually used by JavaScript engine, so you can't directly access it(see more about Object.defineProperty()).That's why the attribute is put in double square brackets instead of single.
"Normal" objects, and functions
A JavaScript object is a mapping between keys and values. Keys are strings (or Symbols) and values can be anything. This makes objects a natural fit for hashmaps.
Functions are regular objects with the additional capability of being callable.
Dates
When representing dates, the best choice is to use the built-in Date utility in JavaScript.
Indexed collections: Arrays and typed Arrays
Arrays are regular objects for which there is a particular relationship between integer-keyed properties and the length property.
Additionally, arrays inherit from Array.prototype, which provides a handful of convenient methods to manipulate arrays. For example, indexOf() searches a value in the array and push() appends an element to the array. This makes Arrays a perfect candidate to represent ordered lists.
Typed Arrays present an array-like view of an underlying binary data buffer, and offer many methods that have similar semantics to the array counterparts. "Typed array" is an umbrella term for a range of data structures, including Int8Array, Float32Array, etc. Check the typed array page for more information. Typed arrays are often used in conjunction with ArrayBuffer and DataView.
Keyed collections: Maps, Sets, WeakMaps, WeakSets
These data structures take object references as keys and are introduced in ECMAScript Edition 6. Set and WeakSet represent a set of objects, while Map and WeakMap associate a value to an object. The difference between Maps and WeakMaps is that in the former, object keys can be enumerated over. This allows garbage collection optimizations in the latter case.
One could implement Maps and Sets in pure ECMAScript 5. However, since objects cannot be compared (in the sense of "less than" for instance), look-up performance would necessarily be linear. Native implementations of them (including WeakMaps) can have look-up performance that is approximately logarithmic to constant time.
Usually, to bind data to a DOM node, one could set properties directly on the object or use data-* attributes. This has the downside that the data is available to any script running in the same context. Maps and WeakMaps make it easy to privately bind data to an object.
Structured data: JSON
JSON (JavaScript Object Notation) is a lightweight data-interchange format, derived from JavaScript but used by many programming languages. JSON builds universal data structures. See JSON and JSON for more details.
More objects in the standard library
JavaScript has a standard library of built-in objects. Please have a look at the reference to find out about more objects.
ไฝฟ็จ typeof ้็ฎๅญไพๅคๆทๅๅฅ
typeof ้็ฎๅญๅฏไปฅๅนซๅฉไฝ ๆพๅฐไฝ ็่ฎๆธๅๅฅ๏ผ่ซ้ฑ่ฎใreference page ใไพๅๅพๆดๅค็ดฐ็ฏๅ้็ทฃๆกไพใ