ECMAScript 中的 Object 对象与 Java 中的 java.lang.Object 相似，ECMAScript 中的所有对象都由这个对象继承而来，Object也是平时使用最多的一个类型，虽然Object的实例不具备多少功能，但对于在应用程序中存储和传输数据而言，它们确实是非常理想的选择。

创建Object实例的方式有两种，第一种是使用new操作符后跟Object构造函数，如下所示：


var person = new Object();
person.name = "zdxiao";
person.age = 2;

第二种是使用对象字面量表示，如下所示：


var person = {
    name: "zdxiao",
    age: 28
};

其他的功能会后面的详细讲解。

2.3.2.Function

函数实际上就是对象，每个函数都是Function类型的实例，而且都与其它引用类型一样具有属性和方法。由于函数是对象，因此函数名实际上也是一个指向函数对象的指针，不会与某个函数绑定。函数定义如下：


function  sum(num1, num2){
    return num1+num2;
}

这与下面使用函数表达式定义函数的方式相差无几。


var sum = function(num1, num2){
    return num1+num2;
};

还有一种定义函数的方式是使用Function构造函数。Function构造函数可以接受任意数量参数，但是最后一个参数始终都被看着是函数体，而前面的参数则枚举出了新函数的参数，语法如下：

var function_name = new function(arg1, arg2, ..., argN, function_body);

如下例子：

var  sum = new Function("num1", "num2", "return num1+num2"); //不推荐

这种写法会导致解析两次代码（第一次是解析常规ECMAScript代码，第二次是解析传入构造函数中的字符串），从而影响性能，不过，这种语法对于理解"函数是对象，函数名是指针"的概念倒是非常直观的。

2.3.3.Array

数组，是个有序列表。数组可以存储对象，数组的大小是可以动态调整的。创建数组的方式有两种，一是使用Array构造函数，如：


var colors = new Array(); //创建一个空的数组
var colors = new Array(20); //创建一个大小为20的数组
 
var colors = Array(2);  //创建一个大小为2的数组
var colors = Array("zdxiao");  //创建一个大小为1的数组

二是使用数组字面量表示，数组字面量由一对包含数组项的方括号表示，多个数组项之间用逗号隔开，如：


var colors = ["21414", "1412412", "fqwfqwf"];
var colors = [];
var colors = [1, 2, "322r23"];

2.3.4.ArrayBuffer

ArrayBuffer 对象用来表示通用的、固定长度的原始二进制数据缓冲区。它是一个字节数组，通常在其他语言中称为“byte array”。

你不能直接操作 ArrayBuffer 的内容，而是要通过类型数组对象或 DataView 对象来操作，它们会将缓冲区中的数据表示为特定的格式，并通过这些格式来读写缓冲区的内容。如下示例：


// create an ArrayBuffer with a size in bytes
const buffer = new ArrayBuffer(8);
console.log(buffer.byteLength);
// expected output: 8

2.3.5.String

String类型是字符串的对象包装类型，可以像下面这样使用String构造函数来创建。

var str = new String("23rt4erfegrth");

还可以直接使用字面量方式，如：

var str1 = 'hello';  //字面量声明方式

两种方式在使用上没有区别，但是在检测数据类型上是有一定的区别。


console.log(typeof str); //返回结果： 'string'
console.log(typeof o_str); //返回结果：'object'

2.3.6.Boolean

Boolean 对象用于转换一个不是 Boolean 类型的值转换为 Boolean 类型值 (true 或者false)。定义如下：


var a = new Boolean(false);
var b = true;

2.3.7.Number

Number 对象是原始数值的包装对象。定义如下：

var numberObject = new Number(10);

2.3.8.DataView

DataView视图是一个可以从二进制ArrayBuffer对象中读写多种数值类型的底层接口，使用它时，不用考虑不同平台的字节序问题。语法:

new DataView(buffer[, byteOffset[, byteLength]]);//参数buffer一个已经存在的ArrayBuffer或Shared

2.3.9.Date

Date 对象用于处理日期与时间。以下四种方法同样可以创建 Date 对象：


var d = new Date();
var d = new Date(milliseconds); // 参数为毫秒
var d = new Date(dateString);
var d = new Date(year, month, day, hours, minutes, seconds, milliseconds);

milliseconds 参数是一个 Unix 时间戳（Unix Time Stamp），它是一个整数值，表示自 1970 年 1 月 1 日 00:00:00 UTC（the Unix epoch）以来的毫秒数。
dateString 参数表示日期的字符串值。
year, month, day, hours, minutes, seconds, milliseconds 分别表示年、月、日、时、分、秒、毫秒。

2.3.10.Promise

Promise 对象用于表示一个异步操作的最终状态（完成或失败），以及其返回的值。

2.3.11.RegExp

正则表达式是描述字符模式的对象。

正则表达式用于对字符串模式匹配及检索替换，是对字符串执行模式匹配的强大工具。

如：


var re = new RegExp("\\w+");
var re = /\w+/;

2.3.12.Map

Map是一组键值对的结构，具有极快的查找速度。定义如下：


var m = new Map([['Michael', 95], ['Bob', 75], ['Tracy', 85]]);
m.get('Michael'); // 95
var n = new Map();

2.3.13.Set

Set和Map类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在Set中，没有重复的key。

要创建一个Set，需要提供一个Array作为输入，或者直接创建一个空Set：


var s1 = new Set(); // 空Set
var s2 = new Set([1, 2, 3]); // 含1, 2, 3

重复元素在Set中自动被过滤：


var s = new Set([1, 2, 3, 3, '3']);
s; // Set {1, 2, 3, "3"}

注意数字3和字符串'3'是不同的元素。

2.3.14.SharedArrayBuffer

SharedArrayBuffer与ArrayBuffer的功能类似，SharedArrayBuffer 与 ArrayBuffer 具有同样的 API。二者的主要区别是 ArrayBuffer 必须在不同执行上下文间切换，SharedArrayBuffer 则可以被任意多个执行上下文同时使用。

2.4.其它属性

2.4.1.Atomics

JavaScript Atomics是一个原子操作库，它使多线程和共享内存的JavaScript编程变得更加容易和可靠。该库提供了一些原子数据类型、原子操作和同步原语，以便开发人员可以更加轻松地编写具有正确同步保证的并发JavaScript程序。

这些原子操作属于 Atomics 模块。与一般的全局对象不同，Atomics 不是构造函数，因此不能使用 new 操作符调用，也不能将其当作函数直接调用。Atomics 的所有属性和方法都是静态的（与 Math 对象一样）。

JavaScript Atomics有以下原子数据类型：

Int8Array
Uint8Array
Int16Array
Uint16Array
Int32Array
Uint32Array
BigInt64Array
BigUint64Array

这些类型都是JavaScript的TypedArray类型，并支持原子操作。

JavaScript Atomics提供了以下原子操作：

Atomics.add()将指定位置上的数组元素与给定的值相加，并返回相加前该元素的值。
Atomics.and()将指定位置上的数组元素与给定的值相与，并返回与操作前该元素的值。
Atomics.compareExchange()如果数组中指定的元素与给定的值相等，则将其更新为新的值，并返回该元素原先的值。
Atomics.exchange()将数组中指定的元素更新为给定的值，并返回该元素更新前的值。
Atomics.isLockFree(size)可以用来检测当前系统是否支持硬件级的原子操作。对于指定大小的数组，如果当前系统支持硬件级的原子操作，则返回 true；否则就意味着对于该数组，Atomics 对象中的各原子操作都只能用锁来实现。此函数面向的是技术专家。
Atomics.load()返回数组中指定元素的值。
Atomics.notify()唤醒等待队列中正在数组指定位置的元素上等待的线程。返回值为成功唤醒的线程数量。
Atomics.or()将指定位置上的数组元素与给定的值相或，并返回或操作前该元素的值。
Atomics.store()将数组中指定的元素设置为给定的值，并返回该值。
Atomics.sub()将指定位置上的数组元素与给定的值相减，并返回相减前该元素的值。
Atomics.wait()检测数组中某个指定位置上的值是否仍然是给定值，是则保持挂起直到被唤醒或超时。返回值为 "ok"、"not-equal" 或 "time-out"。调用时，如果当前线程不允许阻塞，则会抛出异常（大多数浏览器都不允许在主线程中调用 wait()）。
Atomics.xor()将指定位置上的数组元素与给定的值相异或，并返回异或操作前该元素的值。

下面是一个示例程序，展示如何使用Atomics在JavaScript中进行原子操作：


const sharedArray = new Int32Array(new SharedArrayBuffer(4));
Atomics.store(sharedArray, 0, 42);
console.log(Atomics.load(sharedArray, 0)); // 42
Atomics.add(sharedArray, 0, 2);
console.log(Atomics.load(sharedArray, 0)); // 44

在这个示例程序中，我们创建了一个具有一条整数的共享数组。然后，我们使用Atomics.store设置该数组的第一个元素为42。接下来，我们使用Atomics.add将值增加了2。最后，我们使用Atomics.load读取该值。该程序应该输出42和44。

2.4.2.Math

Math是一个内置对象，它拥有一些数学常数属性和数学函数方法，Math不是一个函数对象。与其他全局对象不同的是，Math 不是一个构造器。Math 的所有属性与方法都是静态的。引用圆周率的写法是 Math.PI，调用正余弦函数的写法是 Math.sin(x)，x 是要传入的参数。Math 的常量是使用 JavaScript 中的全精度浮点数来定义的。

Math包中定义的主要函数会在后面详解

2.4.3.JSON

对象表示法，即键值对表示。基本单位是对象。{key:value}

全成JavaScript Object Notation。JS对象简谱。是一种轻量级的数据交换格式。使用JavaScript语法形式，长得很像JavaScript的Object，但是JSON格式仅仅是一个文本，数据类型String。这样，文本String可以被任何编程语言读取，解析，进而作为数据格式传递。

JSON 语法支持表示 3 种类型的值。
1）简单值：字符串、数值、布尔值和 null 可以在 JSON 中出现，就像在 JavaScript 中一样。特殊值 undefined 不可以。如：


3333
“请问该如何体育”

JavaScript 字符串与 JSON 字符串的主要区别是，JSON 字符串必须使用双引号（单引号会导致语法错误）。

布尔值和 null 本身也是有效的 JSON 值。不过，实践中更多使用 JSON 表示比较复杂的数据结构，其中会包含简单值。

2）对象：对象表示有序键/值对。每个值可以是简单值，也可以是复杂类型。如：


let person = {
  name: "Nicholas",
  age: 29
};
let object = {		// js中属性名加上引号，等同于上面的效果
  "name": "Nicholas",
  "age" : 29
};

但 JSON 中的对象必须使用双引号把属性名包围起来。
3）数组：数组表示可以通过数值索引访问的值的有序列表。数组的值可以是任意类型，包括简单值、对象，甚至其他数组。如：

[25, "hi", true]

数组和对象可以组合使用，以表示更加复杂的数据结构。即数组中的元素可以是对象，或对象中的属性值可以为数组。如：


{
"sites":
[{"name":"Runoob", "url":"www.runoob.com"},
{"name":"Google", "url":"www.google.com"},
{"name":"Taobao", "url":"www.taobao.com"}]
}
//site这个key对应的value，是一个数组，3个站点记录的数组。

2.4.4.Reflect

Reflect 是一个内建的对象，用来提供方法去拦截 JavaScript 的操作。
Reflect 不是一个函数对象，所以它是不可构造的，也就是说它不是一个构造器，不能通过 new 操作符去新建或者将其作为一个函数去调用 Reflect 对象。
Reflect 的所有属性和方法都是静态的。

Reflect对象当前有 13 个静态方法。


// 对一个函数进行调用操作，同时可以传入一个数组作为调用参数。
Reflect.apply(target, thisArg, args)	
// 对构造函数进行 new 操作，相当于执行 new target(...args)。
Reflect.construct(target, args)
// 获取对象身上某个属性的值，类似于 target[name]。如果没有该属性，则返回undefined。
Reflect.get(target, name, receiver)
// 将值分配给属性的函数。返回一个Boolean，如果更新成功，则返回true。
Reflect.set(target, name, value, receiver)
// Reflect.defineProperty方法基本等同于Object.defineProperty，直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，不同的是，Object.defineProperty返回此对象。而Reflect.defineProperty会返回布尔值.
Reflect.defineProperty(target, name, desc)
// 作为函数的delete操作符，相当于执行 delete target[name]。
Reflect.deleteProperty(target, name)
// 判断一个对象是否存在某个属性，和 in 运算符 的功能完全相同。
Reflect.has(target, name)
// 返回一个包含所有自身属性（不包含继承属性）的数组。(类似于 Object.keys(), 但不会受enumerable影响, Object.keys返回所有可枚举属性的字符串数组).
Reflect.ownKeys(target)
// 判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）,类似于 Object.isExtensible()。返回表示给定对象是否可扩展的一个Boolean 。（Object.seal 或 Object.freeze 方法都可以标记一个对象为不可扩展。）
Reflect.isExtensible(target)
// 让一个对象变的不可扩展，也就是永远不能再添加新的属性。
Reflect.preventExtensions(target)
// 如果对象中存在该属性，如果指定的属性存在于对象上，则返回其属性描述符对象（property descriptor），否则返回 undefined。类似于 Object.getOwnPropertyDescriptor()。
Reflect.getOwnPropertyDescriptor(target, name)
// 返回指定对象的原型.类似于 Object.getOwnPropertyDescriptor()。
Reflect.getPrototypeOf(target)
// 设置对象原型的函数. 返回一个 Boolean， 如果更新成功，则返回true。如果 target 不是 Object ，或 prototype 既不是对象也不是 null，抛出一个 TypeError 异常。
Reflect.setPrototypeOf(target, prototype)

示例如下：


// Reflect.apply
var obj1 = {};
Reflect.apply(Math.floor, obj1, [1.88]) // 1;
 
// Reflect.construct
const obj2 = Reflect.construct(Date, [2021, 3, 1])
 
// Reflect.get
var obj3 = { x: 1, y: 2 };
Reflect.get(obj3, "x"); // 1
 
// Reflect.set
var obj4 = {};
Reflect.set(obj4, "prop", "value"); // true
 
// Reflect.defineProperty(
const obj5 = {};
Reflect.defineProperty(obj5, 'property', {
  value: 666,
  writable: false
}); // true
 
// Reflect.deleteProperty
var obj6 = { x: 1, y: 2 };
Reflect.deleteProperty(obj6, "x"); // true
obj; // { y: 2 }
 
// Reflect.has
const obj7 = {x: 0}
Reflect.has(obj7, "x"); // true
 
// Reflect.ownKeys
const obj8 = {z: 3, y: 2, x: 1}
Reflect.ownKeys(obj8); // [ "z", "y", "x" ]
 
// Reflect.isExtensible
var obj9 = {};
Reflect.isExtensible(obj9); // true
 
// Reflect.preventExtensions
var obj10 = {};
Reflect.isExtensible(obj10); // true
Reflect.preventExtensions(obj10);
Reflect.isExtensible(obj10); // false
 
// Reflect.getOwnPropertyDescriptor
const obj11 = {x: "hello"}
Reflect.getOwnPropertyDescriptor(obj11, "x");
// {value: "hello", writable: true, enumerable: true, configurable: true}
 
// Reflect.getPrototypeOf
var obj12 = {};
Reflect.getPrototypeOf(obj12); // 等同于Object.prototype
 
// Reflect.setPrototypeOf
var obj13 = {};
Reflect.setPrototypeOf(obj13, null); // true

后面继续写。。。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/170627