DeanPaul
commented
6 years ago 第五章 引 用 类 型
引用类型的值（对象）是引用类型的一个实例（instance） 引用类型是一种数据结构，用于将数据和功能组织在一起。它也常被称为类
对象是某个特定引用类型的实例。新对象是使用 new 操作符后跟一个构造函数来创建的。 构造函数本身就是一个函数，只不过该函数是出于创建新对象的目的而定义的。
Closed DeanPaul closed 6 years ago
DeanPaul
commented
6 years ago 引用类型的值（对象）是引用类型的一个实例（instance） 引用类型是一种数据结构，用于将数据和功能组织在一起。它也常被称为类
对象是某个特定引用类型的实例。新对象是使用 new 操作符后跟一个构造函数来创建的。 构造函数本身就是一个函数，只不过该函数是出于创建新对象的目的而定义的。
DeanPaul
commented
6 years ago var person = {
name : "Nicholas",
age : 29
};
var person = new Object();
person.name = "Nicholas";
person.age = 29; 在通过对象字面量定义对象时，实际上不会调用 Object 构造函数
alert(person["name"]); //"Nicholas" //变量 // 非法字符
alert(person.name); //"Nicholas" var s = new Date();for(let i =0;i<500000000;i++) a =new Array();console.log(new Date()-s)
var s = new Date();for(let i =0;i<500000000;i++) a =[];console.log(new Date()-s)value instanceof Array //？？
Array.isArray(value)var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
alert(colors.toString()); // red,blue,green
alert(colors.valueOf()); // red,blue,green
alert(colors); // red,blue,green
var person1 = {
toLocaleString : function () {
return "Nikolaos";
},
toString : function() {
return "Nicholas";
}
};
var person2 = {
toLocaleString : function () {
return "Grigorios";
},
toString : function() {
return "Greg";
}
};
var people = [person1, person2];
alert(people); //Nicholas,Greg
alert(people.toString()); //Nicholas,Greg
alert(people.toLocaleString());Q1 let keyWords = ["GCD","He","I"]; let content = "Fu GCD is He and I am your ki"; 替换 key words to "逗号"
栈是一种 LIFO（Last-In-First-Out，后进先出）的数据结构，
var colors = new Array(); // 创建一个数组
var count = colors.push("red", "green"); // 推入两项
alert(count); //2
count = colors.push("black"); // 推入另一项
alert(count); //3
var item = colors.pop(); // 取得最后一项
alert(item); //"black"
alert(colors.length); //2 队列数据结构的访问规则是 FIFO（First-In-First-Out，先进先出）
var colors = new Array(); //创建一个数组
var count = colors.push("red", "green"); //推入两项
alert(count); //2
count = colors.push("black"); //推入另一项
alert(count); //3
var item = colors.shift(); //取得第一项
alert(item); //"red"
alert(colors.length); //2 Q2 shift后数组index情况如何
顾名思义，unshift()与 shift()的用途相反： 它能在数组前端添加任意个项并返回新数组的长度
var colors = new Array(); //创建一个数组
var count = colors.unshift("red", "green"); //推入两项
count = colors.unshift("black"); //推入另一项
alert(count); //3
var item = colors.pop(); //取得最后一项
alert(item); //"green" function compare(value1, value2) { if (value1 < value2) { return -1; } else if (value1 > value2) { return 1; } else { return 0; } } var values = [0, 1, 5, 10, 15]; values.sort(compare); alert(values); //0,1,5,10,15
concat 在没有给 concat()方法传递参数的情况下，它只是复制当前数组并返回副本。 如果传递给 concat()方法的是一或多个数组，则该方法会将这些数组中的每一项都添加到结果数组中。 如果传递的值不是数组，这些值就会被简单地添加到结果数组的末尾
var colors = ["red", "green", "blue"];
var colors2 = colors.concat("yellow", ["black", "brown"]);
alert(colors); //red,green,blue
alert(colors2); //red,green,blue,yellow,black,brownslice slice()方法不会影响原始数组
var colors = ["red", "green", "blue", "yellow", "purple"];
var colors2 = colors.slice(1);
var colors3 = colors.slice(1,4); splice 删除：可以删除任意数量的项，只需指定 2 个参数：要删除的第一项的位置和要删除的项数。 例如，splice(0,2)会删除数组中的前两项。 插入：可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、0（要删除的项数） 和要插入的项。如果要插入多个项，可以再传入第四、第五，以至任意多个项。例如， splice(2,0,"red","green")会从当前数组的位置 2 开始插入字符串"red"和"green"。 替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起 始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。例如， splice (2,1,"red","green")会删除当前数组位置 2 的项，然后再从位置 2 开始插入字符串"red"和"green"。
var colors = ["red", "green", "blue"];
var removed = colors.splice(0,1); // 删除第一项
alert(colors); // green,blue
alert(removed); // red，返回的数组中只包含一项
removed = colors.splice(1, 0, "yellow", "orange"); // 从位置 1 开始插入两项
alert(colors); // green,yellow,orange,blue
alert(removed); // 返回的是一个空数组
removed = colors.splice(1, 1, "red", "purple"); // 插入两项，删除一项
alert(colors); // green,red,purple,orange,blue
alert(removed); // yellow，返回的数组中只包含一项indexOf()和 lastIndexOf() ===
every()：对数组中的每一项运行给定函数，如果该函数对每一项都返回 true，则返回 true。 filter()：对数组中的每一项运行给定函数，返回该函数会返回 true 的项组成的数组。 forEach()：对数组中的每一项运行给定函数。这个方法没有返回值。 map()：对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。 some()：对数组中的每一项运行给定函数，如果该函数对任一项返回 true，则返回 true。 都不会修改数组中的包含的值
reduce()和 reduceRight()
var values = [1,2,3,4,5];
var sum = values.reduce(function(prev, cur, index, array){
return prev + cur;
});
alert(sum); //15
函数实际上是对象。每个函数都是 Function 类型的实例，而且都与其他引用类型一样具有属性和方法。由于函数是对象，因此函数名实际上也是一个指向函数对象的指针，不会与某个函数绑定
var f1 = function(){}
var f2 = f1
f1 = null
console.log(f2)创建一个函数 几种方式
function sum (num1, num2) {
return num1 + num2;
}
var sum = function(num1, num2){
return num1 + num2;
};
var sum = new Function("num1", "num2", "return num1 + num2"); // 不推荐
函数名仅仅是指向函数的指针
我们一直没有对函数声明和函数表达式加以区别。而实际上，解析器在向执行环 境中加载数据时，对函数声明和函数表达式并非一视同仁。解析器会率先读取函数声明，并使其在执行 任何代码之前可用（可以访问）；至于函数表达式，则必须等到解析器执行到它所在的代码行，才会真 正被解释执行。
var f1 = function(){}
var str2 = f1 + "--"arguments callee/caller this
它是arguments的一个属性，该属性是一个指针，指向拥有这个 arguments 对象的函数。
1.验证形参和实参长度正确
function calleeDemo(arg1, arg2) {
if (arguments.length == arguments.callee.length) {
console.log("验证形参和实参长度正确！");
return;
}
}
calleeDemo(1); 2.递归 函数名仅仅是一个变量名，在函数内部调用即相当于调用 一个全局变量，不能很好的体现出是调用自身，这时使用callee会是一个比较好的方法
var fn=function(n){
if(n>0) return n+fn(n-1);
return 0;
}
var fn=function(n){
if(n>0) return n+arguments.callee(n-1);
return 0;
} functionName.caller 返回调用者
function caller() {
if (caller.caller) {
console.log(caller.caller.toString());
} else {
console.log("函数直接执行");
}
}
function handleCaller() {
caller();
}
handleCaller();
caller(); window.color = "red";
var o = { color: "blue" };
function sayColor(){
alert(this.color);
}
sayColor(); //"red"
o.sayColor = sayColor;
o.sayColor(); //"blue" 函数是对象，因此函数也有属性和方法。每个函数都包含两个 属性：length 和 prototype。其中，length 属性表示函数希望接收的命名参数的个数，如下面的例 子所示。
function sayName(name){
alert(name);
}
function sum(num1, num2){
return num1 + num2;
}
function sayHi(){
alert("hi");
}
alert(sayName.length); //1
alert(sum.length); //2
alert(sayHi.length); //0 apply()和 call()
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 bind
window.color = "red";
var o = { color: "blue" };
function sayColor(){
alert(this.color);
}
var objectSayColor = sayColor.bind(o);
objectSayColor(); //blue function ab(x){
console.log(x);
var x = 4;
console.log(x);
};
ab(3);
function ab(x){
console.log(x);
var x;
console.log(x);
};
ab(3);function ab(x){
console.log(x);
function x(){
console.log("我是函数")
};
console.log(x);
};
ab(3);连等
DeanPaul
commented
6 years ago String substr()和 substring()
Global对象 “兜底儿对象” 如 isNaN()、isFinite()、parseInt()以及 parseFloat()，实际上全都是 Global 对象的方法。除此之外，Global 对象还包含其他一些方法 URI 编码方法 encodeURI()和 encodeURIComponent()
var uri = "http://www.wrox.com/illegal value.htm#start";
//"http://www.wrox.com/illegal%20value.htm#start"
alert(encodeURI(uri));
//"http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.htm%23start"
alert(encodeURIComponent(uri)); eval() window 对象
xiaodanlee
commented
6 years ago let keyWords = ["GCD","He","I"]; let content = "Fu GCD is He and I am your ki"; let keys = keyWords.join("") let cons = content.split(" "); cons.reduce((prev,cur)=>{ return keys.indexOf(cur)>-1 ? prev+",":prev+" "+cur } //content不一定是以空格为间隔的
第四章 变量、作用域和内存问题
JavaScript 变量的特点--松散类型 有几种类型--基本类型和引用类型
动态的属性
复制变量值
传递参数
检测类型
typeof --基本类型杀手
instanceof
执行环境及作用域
执行环境定义了变量或函数有权访问的其他数据，决定了它们各自的行为。每个执行环境都有一个 与之关联的变量对象（variable object），环境中定义的所有变量和函数都保存在这个对象中。 全局执行环境是最外围的一个执行环境。根据ECMAScript 实现所在的宿主环境不同，表示执行环 境的对象也不一样。在Web 浏览器中，全局执行环境被认为是window 对象，因 此所有全局变量和函数都是作为window 对象的属性和方法创建的。某个执行环境中的所有代码执行完 毕后，该环境被销毁，保存在其中的所有变量和函数定义也随之销毁。 每个函数都有自己的执行环境。当执行流进入一个函数时，函数的环境就会被推入一个环境栈中。 而在函数执行之后，栈将其环境弹出，把控制权返回给之前的执行环境。
当代码在一个环境中执行时，会创建变量对象的一个作用域链（scope chain）。作用域链的用途，是 保证对执行环境有权访问的所有变量和函数的有序访问。作用域链的前端，始终都是当前执行的代码所 在环境的变量对象。如果这个环境是函数，则将其活动对象（activation object）作为变量对象。活动对 象在最开始时只包含一个变量，即arguments 对象（这个对象在全局环境中是不存在的）。作用域链中 的下一个变量对象来自包含（外部）环境，而再下一个变量对象则来自下一个包含环境。这样，一直延 续到全局执行环境；全局执行环境的变量对象始终都是作用域链中的最后一个对象。 标识符解析是沿着作用域链一级一级地搜索标识符的过程。搜索过程始终从作用域链的前端开始， 然后逐级地向后回溯，直至找到标识符为止（如果找不到标识符，通常会导致错误发生）。
延长作用域链
with
try-catch 语句的catch 块 当try代码块中发生错误时，执行过程会跳转到catch语句，然后把异常对象推入一个可变对象并置于作用域的头部。在catch代码块内部，函数的所有局部变量将会被放在第二个作用域链对象中。示例代码：
try{ doSomething(); }catch(ex){ alert(ex.message); //作用域链在此处改变 }
没有块级作用域
垃圾收集
标记清除
当变量进入环境（例如，在函数中声明一个变量）时，就将这个变量标记为“进入环境”。从逻辑上讲，永远不能释放进入环境的变量所占用的内存，因为只要执行流进入相应的环境，就可能会用到它们。而当变量离开环境时，则将其标记为“离开环境”。垃圾收集器在运行的时候会给存储在内存中的所有变量都加上标记（当然，可以使用任何标记方式）。然后，它会去掉环境中的变量以及被环境中的变量引用的变量的标记。而在此之后再被加上标记的变量将被视为准备删除的变量，原因是环境中的变量已经无法访问到这些变量了。最后，垃圾收集器完成内存清除工作，销毁那些带标记的值并回收它们所占用的内存空间
引用计数
另一种不太常见的垃圾收集策略叫做引用计数（reference counting）。引用计数的含义是跟踪记录每 个值被引用的次数。当声明了一个变量并将一个引用类型值赋给该变量时，则这个值的引用次数就是1。 如果同一个值又被赋给另一个变量，则该值的引用次数加1。相反，如果包含对这个值引用的变量又取 得了另外一个值，则这个值的引用次数减1。当这个值的引用次数变成0 时，则说明没有办法再访问这 个值了，因而就可以将其占用的内存空间回收回来。这样，当垃圾收集器下次再运行时，它就会释放那 些引用次数为零的值所占用的内存。 Netscape Navigator 3.0 是最早使用引用计数策略的浏览器，但很快它就遇到了一个严重的问题：循 环引用。循环引用指的是对象A 中包含一个指向对象B 的指针，而对象B 中也包含一个指向对象A 的 引用。请看下面这个例子：
管理内存
解除引用（dereferencing) function createPerson(name){ var localPerson = new Object(); localPerson.name = name; return localPerson; } var globalPerson = createPerson("Nicholas"); // 手工解除globalPerson 的引用 globalPerson = null;