JavaScript 编程：4. 引用类型

引用类型

Object 类型

创建 Object 实例的两种方式:

// 1，使用 new 操作符后跟 Object 构造函数
var person = new Object();
person.name = "Nicholas";
person.age = 29;


// 2.1，对象字面量表示法
var person = {
    name : "Nicholas",
    age : 29   // 最后一个属性后面不能添加逗号。
};
// 在最后一个属性后面添加逗号，会在 IE7 及更早版本和 Opera 中导致错误。


// 2.2，属性名也可以使用字符串
var persion = {
    "name" : "Nicholas",
    "age" : 29,
    5 : true // 这里的数值属性会自动转换为字符串
}

// 2.3
var person = {}; // 与 new Object() 相同

访问属性的两种方式：

// 1.点语法
alert(person.name);

// 2.方括号表示法
alert(person["name"]);

// 方括号语法的优点：可以通过变量访问属性
var propertyName = "name";   // 属性名是 name，把 name 赋值给变量
alert(person[propertyName]); // 通过变量访问属性

// 方括号的属性名中还可以包含会导致语法错误的字符、关键字、保留字。
person["first name"] = "Nicholas";

💡通常，除非必须使用变量来访问属性，否则我们建议使用点表示法。

Array 类型

ECMAScript 数组的每一项可以保存任何类型的数据。
ECMAScript 数组的大小是可以动态调整的，即可以随着数据的添加自动增长以容纳新增数据。

//---------------------
// 创建数组的两种基本方式
// 1.使用Array构造函数
var colors = new Array();
// 创建 length 值为20的数组
var colors = new Array(20);
var colors = new Array("red", "blue", "green");

// 给构造函数传递一个值来创建数组
var colors = new Array(3);    // 1. 如果传入参数为数值，创建一个包含3项的数组
var names = new Array("Tom"); // 2. 如果传入参数为字符串，创建一个包含1项，即字符串“Tom”的数组

// 可以省略 new 操作符
var colors = Array(3);

// 2.使用数组字面量表示
var colors = ["red", "blue", "green"];
var name = [];


//---------------------
// 数组的 length 属性很有特点——它不是只读的。因此，通过设置这个属性，可以从数组的末尾移除项或向数组中添加新项。
var colors = ["red", "blue", "green"];
colors.length = 2;
console.log(colors[2]); // undefined

// 利用 length 属性在末尾添加新项
var colors = ["red", "blue", "green"]; // 创建一个包含3个字符串的数组
colors[colors.length] = "black";       // 在位置3添加一种颜色
colors[colors.length] = "brown";       // 在位置4添加一种颜色


//---------------------
// 检测数组
if(colors instanceof Array) {
    // 对数组执行某些操作
    // instanceof 只假定单一的全局执行环境
    // 如果网页中包含多个框架，那实际上就存在两个以上不同的全局执行环境，从而存在两个以上不同版本的 Array 构造函数。如果你从一个框架向另一个框架传入一个数组，那么传入的数组与在第二个框架中原生创建的数组分别具有各自 不同的构造函数。
}

// 最终确定某个值到底是不是数组
if(Array.isArray(colors)) {
    // 对数组执行某些操作 
}


//---------------------
// 转换方法
alert(colors.toString()); //red,blue,green
alert(colors.valueOf());  //red,blue,green
alert(colors);            //red,blue,green，直接传递数组在后台会调用 toString() 方法
alert(colors.toLocaleString());
alert(colors.join("||")); //red||blue||green , join() 函数用于指定分隔符

// 如果数组中的某一项的值是 null 或者 undefined，那么该值在 join()、 toLocaleString()、toString()和 valueOf()方法返回的结果中以空字符串表示。

//---------------------
// 栈方法
colors.push("red"); // 在数组末尾推入新项，返回数组的长度
colors.pop();       // 从数组末尾移除最后一项，返回移除的项
// 队列方法
var item = colors.shift(); // 移除数组中的第一项并返回该项
var count= colors.unshift("red"); // 在数组前端添加任意个项并返回新数组的长度

//---------------------
// 重排序方法
var values = [1, 2, 3, 4, 5];
values.reverse(); // 反转数组项的顺序
values.sort();    // 默认字符串升序排序，即最小的值位于最前面，最大的值排在最后面。

// sort()方法可以接收一个比较函数作为参数，以便我们指定哪个值位于哪个值的前面。
// 1.构造比较函数
function compare(value1, value2) {
    // 如果第一个参数应该位于第二个参数之前，则返回负数。
    // 如果第一个参数应该位于第二个参数之后，则返回正数。
    // 如果两个参数相等，则返回0
    if(value1 < value2) {
        return -1; // 
    }else if (value1 > value2) {
        return 1;
    }else {
        return 0;
    }
}
// 2.将比较函数作为参数传递给 sort()
values.sort(compare);

// 对于数值类型或者其 valueOf() 方法会返回数值类型的对象类型，可以使用一个更简单的比较函数。
// 降序排序函数：
function compare(value1, value2) {
    return value2 - value1;
}

//---------------------
// 操作方法
// 1. concat()：基于当前数组中的所有项创建一个新数组
var colors = ["red", "green", "blue"];
var colors2 = colors.concat["yellow", ["black", "brown"]];

alert(colors2); // red,green,blue,yellow,black,brown

// 2. slice()：基于当前数组中的一个或多个项创建一个新数组
var colors = ["red", "green", "blue", "yellow", "purple"];
// 指定一个参数，指定位置开始到结尾
var colors2 = colors.slice(1);    // green,blue,yellow,purple
// 指定两个参数，返回起始和结束位置之间的项，但不包括结束位置的项
var colors3 = colors.slice(1, 4); // green,blue,yellow

// ⭐️⭐️⭐️
// 3. splice()：向数组的中部插入项
// splice()方法始终会返回一个数组，该数组中包含从原始数组中删除的项
// 3.1 删除，可以删除任意数量的项。指定两个参数，要删除的第一项位置和要删除的项数。
var colors4 = colors.splice(0, 2); 

// 3.2 插入，向指定位置插入任意数量的项。提供3个参数，起始位置、0（要删除的项数）和要插入的项...
var colors5 = colors.splice(2, 0 , "red", "green"); 

// 3.3 替换，向指定位置插入任意数量的项，且同时删除任意数量的项
var colors6 = colors.splice(2, 1 , "red", "green"); 


//---------------------
// 位置方法，返回要查找的项在数组中的位置，全等操作符（===）查找
// indexOf()：从数组的开头开始向后查找
// lastIndexOf()：从数组的末尾开始向前查找
// 如果未查到，返回-1
var numbers = [1,2,3,4,5,4,3,2,1];

alert(numbers.indexOf(4)); // 3
alert(numbers.lastIndexOf(4)); // 5

// 参数一：要查找的项；参数二：查找起点位置的索引
alert(numbers.indexOf(4,4)); // 5
alert(numbers.lastIndexOf(4,4)); // 3

//---------------------
// 迭代方法
// every()：对数组中的每一项运行给定函数，如果该函数对每一项返回true，则返回true。
// filter()：对数组中的每一项运行给定函数，返回该函数会返回true的项组成的数组。
// forEach()：对数组中的每一项运行给定函数，没有返回值。
// map()：对数组中的每一项运行给定函数，返回每次函数调用结果组成的数组。
// some()：对数组中的每一项运行给定函数，如果该函数对任一项返回true，则返回true。

var numbers = [1,2,3,4,5,4,3,2,1];

var everyResult = numbers.every(function(item, index, array){
   return (item > 2); 
}); 
alert(everyResult); // false

var someResult = numbers.some(function(item, index, array){
   return (item > 2); 
}); 
alert(someResult); // true

var filterResult = numbers.filter(function(item, index, array){
    return (item > 2);
});
alert(filterResult); // [3,4,5,4,3],只返回满足条件的结果

var mapResult = numbers.map(function(item, index, array){
    return item * 2;
});
alert(mapResult); // [2,4,6,8,10,8,6,4,2]，返回每个调用结果


//---------------------
// 归并方法
// reduce()，从数组的第一项开始，逐个遍历到最后。
// reduceRight()，从数组的最后一项开始，向前遍历到第一项。
// 这两个方法都接收两个参数，参数一：一个在每一项上调用的函数；参数二：作为归并基础的初始值。
// 函数的四个参数：前一个值、当前值、项的索引和数组对象
var values = [1, 2, 3, 4, 5];
var sum = values.reduce(function(prev, cur, index, array){
   return prev + cur; 
});
alert(sum); // 15

Date 类型

//---------------------
// Date 类型
// 创建一个日期对象
var nowDate = new Date();
var result = nowDate.toLocaleDateString() + " "+ nowDate.toLocaleTimeString();
console.log(result); // 10/19/2018 5:10:38 PM

// Date.parse()方法接收一个表示日期的字符串参数，然后尝试根据这个字符串返回相应日期的毫秒数。
var someDate = new Date(Date.parse("May 25, 2004"));
// Date.UTC()的参数分别是年份、基于 0 的月份(一月是 0，二月是 1，以此类推)、月中的哪一天(1 到 31)、小时数(0 到 23)、分钟、秒以及毫秒数。在这些参数中，只有前两个参数(年和月)是必需的。如果没有提供月中的天数，则假设天数为 1;如果省略其他参数，则统统假设为 0。
var y2k = new Date(Date.UTC(2000. 0)); // 2000年一月一日午夜零点
var allFives = new Date(Date.UTC(2005, 4, 5, 17, 55, 55)); // 2005/5/5 下午5:55:55


// 取得开始时间
var date = Date.now();

console.log(date); // 毫秒结果：1539938296542
console.log(date.toString()); // 1539939024850
console.log(date.toLocaleString()); // 1,539,939,024,850
// 调用函数
doSomething();
// 取得停止时间
var stop = Date.now(),
    result = stop - start;

// Data 类型的 valueOf() 方法返回日期的毫秒表示，因此，可以方便的使用比较操作符（小于或大于）来比较日期值。
var date1 = new Date(2018, 10, 6);
var date2 = new Date(2018, 9, 6);
console.log(date1 < date2); // false

// 日期格式化方法
// toDateString()——星期、月、日、年
// toTimeString()——时分秒和时区
// toLocalDateString()
// toLocalTimeString()
// toUTCString()
// toLocalString()/toString()

参考：npm: moment.js

RegExp 类型

var expression = /pattern / flags ;

flags 标志值
g	全局模式
i	忽略大小写
m	多行模式

// 字面量模式
/*
 * 匹配字符串中所有“at”的实例
 */
var pattern1 = /at/g

/*
 * 匹配第一个“bat”或“cat”，不区分大小写
 */
var pattern2 = /[bc]at/i

// 使用构造函数模式
var pattern3 = new RegExp("[bt]at", "i");

由于 RegExp 构造函数的模式参数是字符串，所以在某些情况下要对字符进行双重转义。所有元字符都必须双重转义，那些已经转义过的字符也是如此。
使用正则表达式字面量和使用 RegExp 构造函数创建的正则表达式不一样。在 ECMAScript 3 中，正则表达式字面量始终会共享同一个 RegExp 实例，而使用构造函数创建的每一个新 RegExp 实例都是一个新实例。
ECMAScript 5 明确规定，使用正则表达式字面量必须像直接调用 RegExp 构造函数一样，每次都创建新的 RegExp 实例。IE9+、Firefox 4 + 和 Chrome 都据此做出了修改。

RegExp 实例属性

RegExp 的实例属性都具有下列属性，通过这些属性可以取得有关模式的各种信息。

global：布尔值，表示是否设置了 g 标志。
ignoreCase：布尔值，表示是否设置了 i 标志。
lastIndex：整数，表示开始搜索下一个匹配项的字符位置，从 0 算起。
multiline：布尔值，表示是否设置了 m 标志。
source：正则表达式的字符串表示，按照字面量形式而非传入构造函数中的字符串模式返回。

RegExp 实例方法

exec () 方法

RegExp 对象的主要方法是 exec ()，该方法是专门为捕获组而设计的。exec () 接受一个参数，即要应用模式的字符串，然后返回包含第一个匹配项信息的数组；或者在没有匹配项的情况下返回 null。返回的数组虽然是 Array 的实例，但包含两个额外的属性:index 和 input。

其中，index 表示匹配项在字符串中的位置，而 input 表示应用正则表达式的字符串。

在数组中，第一项是与整个模式匹配的字符串，其他项是与模式中的捕获组匹配的字符串 (如果模式中没有捕获组，则该数组只包含一项)。

var text = "mom and dad and baby";
var pattern = /mom( and dad( and baby)?)?/gi;

var maches  = pattern.exec(text);
console.log(maches.index); // 0
console.log(maches.input); // "mom and dad and baby"
console.log(maches[0]);    // "mom and dad and baby"
console.log(maches[1]);    // " and dad and baby"
console.log(maches[2]);    // " and baby"

对于 exec () 方法而言，即使在模式中设置了全局标志 (g)，它每次也只会返回一个匹配项。

在不设置全局标志的情况下，在同一个字符串上多次调用 exec () 将始终返回第一个匹配项的信息。
而在设置全局标志的情况下，每次调用 exec () 则都会在字符串中继续查找新匹配项

test () 方法

它接受一个字符串参数。在模式与该参数匹配的情况下返回 true；否则，返回 false。在只想知道目标字符串与某个模式是否匹配，但不需要知道其文本内容的情况下，使用这个方法非常方便。因此，test () 方法经常被用在 if 语句中。

RexExp 构造函数属性

使用这些属性可以从 exec () 或 test () 执行的操作中提取出更具体的信息。

Function 类型

函数声明 & 函数表达式

// 1.函数声明语法
// 函数声明提升：解析器会率先读取函数声明，并使其在执行任何代码之前可用。
alert(sum(10,10));
function sum (num1, num2) {
    return num1 + num2;
}

// 2.函数表达式语法
// 必须等到解析器执行到它所在的代码行，才会真正被解释执行。
var sum = function(num1, num2) {
    return num1 + num2;
};

// 除了什么时候可以通过变量访问函数这一点区别之外，函数声明与函数表达式的语法其实是等价的。

// 3.Function 构造函数
var sum = new Function("num1", "num2", "return num1 + num2"); // 不推荐

函数是对象，函数名是指针
使用不带圆括号的函数名是访问函数指针，而非调用函数。
JavaScript 函数没有重载。
不仅可以像传递参数一样把一个函数传递给另一个函数，而且可以将一个函数作为另一个函数的结果返回。
```
function callSomeFunction(someFunction, someArgument) {
  return someFunction(someArgument);
}
```

函数内部属性

arguments 对象有一个 callee 属性，该属性是一个指针，指向拥有这个 arguments 对象的函数。
当函数在严格模式下运行时，访问 arguments.callee 会导致错误。
this 引用的是函数据以执行的环境对象 —— 或者也可以说是 this 值（当在网页的全局作用域中调用函数时，
this 对象引用的就是 window）。

// arguments.callee 属性，指向函数本身
// 示例：阶乘函数
function factorial(num) {
    if(num <= 1) {
        return 1;
    }else {
        return num * arguments.callee(num -1);
    }
}

// this，函数据以执行的环境对象
window.color = "red";
var o = {color:"blue"};

function sayColor() {
    alert(this.color);
};

// 当在全局作用域中调用 sayColor() 时，this 引用的是全局对象 window
sayColor(); // "red"
o.sayColor = sayColor;
o.sayColor(); // "blue"


// arguments.callee.caller // caller 属性表示调用当前函数的引用
// 函数的属性和方法

函数属性和方法

ECMAScript 中的函数是对象，因此函数也有属性和方法。每个函数都包含两个属性:length 和 prototype。

length：属性表示函数希望接收的命名参数的个数。
prototype：对于 ECMAScript 中的引用类型而言，prototype 是保存它们所有实例方法的真正所在。
在 ECMAScript 5 中，prototype 属性是不可枚举的，因此使用 for-in 无法发现。

每个函数都包含两个非继承而来的方法：apply() 和 call()。这两个方法的用途都是在特定的作用域中调用函数，实际上等于设置函数体内 this 对象的值。

apply() 方法接收两个参数：一个是在其中运行函数的作用域，另一个是参数数组。其中，第二个参数可以是 Array 的实例，也可以是 arguments 对象。

<!–hexoPostRenderEscape:
```
function sum(num1, num2) {
  return num1 + num2;
}
function callSum1(num1, num2) {
  return sum.apply(this, arguments);
}
function callSum2(num1, num2) {
  return sum.apply(this, [num1, num2]);
}
```

console.log(callSum1(10,10)); // 20 console.log(callSum2(10,10)); // 20:hexoPostRenderEscape–>

call() 方法与 apply() 方法的作用相同，它们的区别仅在于接收参数的方式不同。对于 call() 方法而言，第一个参数是 this 值没有变化，变化的是其余参数都直接传递给函数。换句话说，在使用 call() 方法时，传递给函数的参数必须逐个列举出来.

<!–hexoPostRenderEscape:
```
function sum(num1, num2) {
  return num1 + num2;
}
function callSum1(num1, num2) {
  return sum.call(this, num1, num2);
}
```

console.log(callSum1(10,10)); // 20:hexoPostRenderEscape–>

传递参数并非 apply() 和 call() 真正的用武之地，它们真正强大的地方是能够扩充函数赖以运行的作用域。使用 call() 或 apply() 来扩充作用域的最大好处，就是对象不需要与方法有任何耦合关系。

<!–hexoPostRenderEscape:
```
window.color = "red";
var o = {color:"blue"};
```


function sayColor() {
    alert(this.color);
};
sayColor(); // “red”

sayColor.call(this); // red sayColor.call(window); // red sayColor.call(o); // blue:hexoPostRenderEscape–>

ECMAScript 5 还定义了一个方法：bind()。这个方法会创建一个函数的实例，其 this 值会被绑
定到传给 bind() 函数的值。

<!–hexoPostRenderEscape:
```
window.color = "red";
var o = {color:"blue"};
```


function sayColor() {
    alert(this.color);
};

var objectSayColor = sayColor.bind(o); // 即使在全局作用域下调用 objectSayColor()，它的 this 值也是 o objectSayColor(); //blue:hexoPostRenderEscape–>

基本包装类型

为了便于操作基本类型值，ECMAScript 还提供了 3 个特殊的引用类型：Boolean、Number 和
String。
实际上，每当读取一个基本类型值的时候，后台就会创建一个对应的基本包装类型的对象，以便我们进行操作。
Object 构造函数也会像工厂方法一样，根据传入值的类型返回相应基本包装类型的实例。
- 把字符串传给 Object 构造函数，就会创建 String 的实例；
- 而传入数值参数会得到 Number 的实例。传入布尔值参数就会得到 Boolean 的实例。
```
var obj = new Object("some text");
console.log(obj instanceof String); //true
```
使用 new 调用基本包装类型的构造函数，与直接调用同名的转型函数是不一样的。

<!–hexoPostRenderEscape:
```
var value = "25";
```


// 变量 number 中保存的是基本类型的值 25
var number = Number(value); //转型函数
console.log(typeof number); //“number”

// 变量 obj 中保存的是 Number 的实例 var obj = new Number(value) //构造函数 console.log(typeof obj); //“object”:hexoPostRenderEscape–>

基本类型与引用类型的布尔值有区别，建议永远不要使用 Boolean 对象。
Number 类型还提供了用于将数值格式化为字符串的方法：
- toFixed()：按照指定的小数位返回数值的字符串表示。
- toExponential()：返回以指数表示法 (也称 e 表示法) 表示的数值的字符串形式。
- toPrecision()：该方法接收一个参数，即表示数值的所有数字的位数 (不包括指数部分)。toPrecision() 会根据要处理的数值决定到底是调用 toFixed() 还是调用 toExponential()。
```
var num = 99;
console.log(num.toPrecision(1)); // 1e+2
console.log(num.toPrecision(2)); // 99
console.log(num.toPrecision(3)); // 99.0
```

String 类型

String 对象的方法也可以在所有基本的字符串值中访问到。

字符方法：charAt() 和 charCodeAt()；

var stringValue = "hello world";
console.log(stringValue.charAt(1)); // 返回字符："e"
console.log(stringValue.charCodeAt(1)); // 返回字符编码："101"
console.log(stringValue[1]); // 使用方括号加数字索引来访问字符串中的特定字符

字符串操作符方法：concat() ：拼接字符串。
基于子字符串创建新字符串的方法：slice()、substr() 和 substring()。
字符串位置方法：indexOf() 和 lastIndexOf()。
- indexOf() 方法从字符串的开头向后搜索子字符串。
- lastIndexOf() 方法是从字符串的末尾向前搜索子字符串。

trim() 方法：创建一个字符串的副本，删除前置及后缀的所有空格，然后返回结果。

var stringValue = "     hello world    ";
var trimmedStringValue = stringValue.trim(); 
console.log(trimmedStringValue); // "hello world"

字符串大小写转换方法：
- toLowerCase()
- toLocaleLowerCase()
- toUpperCase()
- toLocaleUpperCase()
字符串的模式匹配方法:
- match()，在字符串上调用这个方法，本质上与调用 RegExp 的 exec() 方法相同。
- search()，返回字符串中第一个匹配项的索引；如果没有找到匹配项，则返回 - 1。而且 search() 方法始终是从字符串开头向后查找模式。
- replace()，替换字符串方法。
- split()，基于指定的分隔符将一个字符串分割成多个子字符串，并将结果放在一个数组中。
localeCompare() 方法，字符串比较。
fromCharCode() 方法，接收一或多个字符编码，然后将它们转换成一个字符串。
HTML 方法。

单体内置对象

内置对象：由 ECMAScript 实现提供的、不依赖于宿主环境的对象。

内置对象：例如 Object、Array 和 String。
ECMA-262 还定义了两个单体内置对象：Global 和 Math。

Global 对象

URL 编码方法：`encodeURL()` 和 `encodeURIComponent()`

使用 encodeURL() 编码后的结果是除了空格之外的其他字符都原封不动，只有空格被替换成了
%20。
encodeURIComponent() 方法则会使用对应的编码替换所有非字母数字字符。

URL 解码方法：`decodeURI()` 和 `decodeURIComponent()`

`eval()` 方法

该方法就像是一个完整的 ECMAScript 解析器，它只接受一个参数，即要执行的 ECMAScrip (t 或 JavaScript)
字符串。

Global 对象的属性

windows 对象

ECMAScript 虽然没有指出如何直接访问 Global 对象，但 Web 浏览器都是将这个全局对象作为 window 对象的一部分加以实现的。因此，在全局作用域中声明的所有变量和函数，就都成为了 window 对象的属性。

Math 对象

Math 对象的属性

`min()` 和 `max()` 方法

用于确定一组数值中的最小值和最大值。

舍入方法

Math.ceil () 执行向上舍入，即它总是将数值向上舍入为最接近的整数；
Math.floor () 执行向下舍入，即它总是将数值向下舍入为最接近的整数；
Math.round () 执行标准舍入，即它总是将数值四舍五入为最接近的整数

`random()` 方法

Math.random () 方法返回大于等于 0 小于 1 的一个随机数。

独木舟的木

JavaScript 编程：4. 引用类型

引用类型

Object 类型

Array 类型

Date 类型

RegExp 类型

RegExp 实例属性

RegExp 实例方法

exec () 方法

test () 方法

RexExp 构造函数属性

Function 类型

函数声明 & 函数表达式

函数内部属性

函数属性和方法

基本包装类型

String 类型

单体内置对象

Global 对象

URL 编码方法：`encodeURL()` 和 `encodeURIComponent()`

URL 解码方法：`decodeURI()` 和 `decodeURIComponent()`

`eval()` 方法

Global 对象的属性

windows 对象

Math 对象

Math 对象的属性

`min()` 和 `max()` 方法

舍入方法

`random()` 方法

其他方法

引用类型

Object 类型

Array 类型

Date 类型

RegExp 类型

RegExp 实例属性

RegExp 实例方法

exec () 方法

test () 方法

RexExp 构造函数属性

Function 类型

函数声明 & 函数表达式

函数内部属性

函数属性和方法

基本包装类型

String 类型

单体内置对象

Global 对象

URL 编码方法：encodeURL() 和 encodeURIComponent()

URL 解码方法：decodeURI() 和 decodeURIComponent()

eval() 方法

Global 对象的属性

windows 对象

Math 对象

Math 对象的属性

min() 和 max() 方法

舍入方法

random() 方法

其他方法

URL 编码方法：`encodeURL()` 和 `encodeURIComponent()`

URL 解码方法：`decodeURI()` 和 `decodeURIComponent()`

`eval()` 方法

`min()` 和 `max()` 方法

`random()` 方法