引用类型
image
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()
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 构造函数属性
image
使用这些属性可以从 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 对象。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 -
call()方法与apply()方法的作用相同，它们的区别仅在于接收参数的方式不同。对于call()方法而言，第一个参数是 this 值没有变化，变化的是其余参数都直接传递给函数。换句话说，在使用call()方法时，传递给函数的参数必须逐个列举出来.function sum(num1, num2) { return num1 + num2; } function callSum1(num1, num2) { return sum.call(this, num1, num2); } console.log(callSum1(10,10)); // 20 -
传递参数并非
apply()和call()真正的用武之地，它们真正强大的地方是能够扩充函数赖以运行的作用域。使用call()或apply()来扩充作用域的最大好处，就是对象不需要与方法有任何耦合关系。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 -
ECMAScript 5 还定义了一个方法：
bind()。这个方法会创建一个函数的实例，其 this 值会被绑
定到传给bind()函数的值。window.color = "red"; var o = {color:"blue"}; function sayColor() { alert(this.color); }; var objectSayColor = sayColor.bind(o); // 即使在全局作用域下调用 objectSayColor()，它的 this 值也是 o objectSayColor(); //blue
基本包装类型
-
为了便于操作基本类型值，ECMAScript 还提供了 3 个特殊的引用类型：Boolean、Number 和
String。 -
实际上，每当读取一个基本类型值的时候，后台就会创建一个对应的基本包装类型的对象，以便我们进行操作。
-
Object 构造函数也会像工厂方法一样，根据传入值的类型返回相应基本包装类型的实例。
- 把字符串传给Object 构造函数，就会创建 String 的实例；
- 而传入数值参数会得到 Number 的实例。传入布尔值参数就会得到 Boolean 的实例。
var obj = new Object("some text"); console.log(obj instanceof String); //true -
使用 new 调用基本包装类型的构造函数，与直接调用同名的转型函数是不一样的。
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" -
基本类型与引用类型的布尔值有区别，建议永远不要使用 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 对象的属性
image
windows 对象
ECMAScript 虽然没有指出如何直接访问 Global 对象，但 Web 浏览器都是将这个全局对象作为 window 对象的一部分加以实现的。因此，在全局作用域中声明的所有变量和函数，就都成为了 window 对象的属性。
Math 对象
Math 对象的属性
image
min() 和 max() 方法
用于确定一组数值中的最小值和最大值。
舍入方法
- Math.ceil() 执行向上舍入，即它总是将数值向上舍入为最接近的整数;
- Math.floor() 执行向下舍入，即它总是将数值向下舍入为最接近的整数;
- Math.round() 执行标准舍入，即它总是将数值四舍五入为最接近的整数
random() 方法
Math.random() 方法返回大于等于 0 小于 1 的一个随机数。
其他方法
image
网友评论