JS第三版学习1~5章

JS第三版学习1~5章

一、语法知识小点

• js三个部分：

  • 1.ECMAScript，由 ECMA-262 定义，提供核心语言功能；
  • 2.文档对象模型（DOM），提供访问和操作网页内容的方法和接口；
  • 3.浏览器对象模型（BOM），提供与浏览器交互的方法和接口。

• 输出数据的四种方式:

  • 使用window.alert()弹出警告
  • document.write()将内容写进html文档
  • 使用innerHTML
  • 使用console.log()写入控制台

• js数据类型

  • 值类型(基本类型)
    • 字符串string 数字number 布尔boolean 对空null 未定义undefined
  • 引用数据类型
    • 对象object 数组array 函数function

var person=
{
	firstname : "John",
	lastname  : "Doe",
	id        :  5566
};
//访问对象的两种形式
person.lastName;
person["lastName"];

1. 变量是一个名称字面量是一个值
2. 使用\进行换行
3. js变量均为对象，当您声明一个变量时，即创建了一个新的对象
4. 键值对也叫做对象属性
5. defer属性只适应于外部脚本文件
6. 用var定义的变量将成为该变量作用于中的局部变量
7. NaN和任何值都不相等，包括他本身，0/0会返回NaN，正数/负数除以0分别返回infinity -infinity
8. 如果把值赋给尚为未声明的变量该变量将自动作为window的属性，全局变量是window对象
9. 事件既可以是浏览器行为，也可以是用户行为，其可以用于处理表单验证、用户输入、用户行为及浏览器动作

alert(isNaN("blue")); //true（不能转换成数值）
alert(isNaN(true)); //false（可以被转换成数值 1）
var x = "John";             
var y = new String("John");
(x === y) // 结果为 false，因为 x 是字符串，y 是对象

1. ===绝对等于，（值和类型均相等）
2. for in语句循环遍历对象的属性
3. 通过标签引用，break 语句可用于跳出任何 JavaScript 代码块.continue只用于循环，例子中的list不能用continue

var person={fname:"John",lname:"Doe",age:25}; 
 
for (x in person)  // x 为属性名
{
    txt=txt + person[x];
}


cars=["BMW","Volvo","Saab","Ford"];
list: 
{
    document.write(cars[0] + "<br>"); 
    document.write(cars[1] + "<br>"); 
    document.write(cars[2] + "<br>"); 
    break list;
    document.write(cars[3] + "<br>"); 
    document.write(cars[4] + "<br>"); 
    document.write(cars[5] + "<br>"); 
}

清空对象(null 和 undefined 的值相等，但类型不等)：
1.var person = null; // 值为 null(空), 但类型为对象
2.var person = undefined; // 值为 undefined, 类型为 undefined
（1）undefined：是所有没有赋值变量的默认值，自动赋值。
（2）null：主动释放一个变量引用的对象，表示一个变量不再指向任何对象地址。
如果对象是 JavaScript Array 或 JavaScript Date ，我们就无法通过 typeof 来判断他们的类型，因为都是 返回 object。

"John".constructor                 // 返回函数 String()
(3.14).constructor                 // 返回函数 Number()
false.constructor                  // 返回函数 Boolean()
[1,2,3,4].constructor              // 返回函数 Array()
{name:'John', age:34}.constructor  // 返回函数 Object()
new Date().constructor             // 返回函数 Date()
function () {}.constructor         // 返回函数 Function()

Operator + 可用于将变量转换为数字如果变量不能转换则值=NaN
var y = “5”; // y 是一个字符串
var x = + y; // x 是一个数字
var y = “John”; // y 是一个字符串
var x = + y; // x 是一个数字 (NaN)
“5” + 1 // 返回 “51” 1 转换为 “1”
“5” - 1 // 返回 4 “5” 转换为 5

• this

  • 在方法中，this 表示该方法所属的对象。
  • 如果单独使用，this 表示全局对象。
  • 在函数中，this 表示全局对象。
  • 在函数中，在严格模式下，this 是未定义的(undefined)。
  • 在事件中，this 表示接收事件的元素。
  • this 引用到任何对象。

• 正则表达式

  • search() 方法 用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串，并返回子串的起始位置
  • replace() 方法 用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串
  • test()方法
    • /e/.test(“The best things in life are free!”)返回true找到了e
  • exec() 方法用于检索字符串中的正则表达式的匹配。
    该函数返回一个数组，其中存放匹配的结果。如果未找到匹配，则返回值为 null。/e/.exec(“The best things in life are free!”);返回e

• 异常处理

  • try 语句测试代码块的错误catch 语句处理错误。throw 语句创建自定义错误。finally 语句在 try 和 catch 语句之后，无论是否有触发异常，该语句都会执行。

try { 
        if(x == "")  throw "值为空";
        if(isNaN(x)) throw "不是数字";
        x = Number(x);
        if(x < 5)    throw "太小";
        if(x > 10)   throw "太大";
    }
    catch(err) {
        message.innerHTML = "错误: " + err;
    }
}

arguments对象是一个对应于传递给函数参数的类数组对象

第四章（变量作用域内存）

• 1、 动态的属性
  • 当复制保存着对象的某个变量时，操作的是对象的引用，但在为对象添加属性时，操作的是实际的对象（不能给基本类型添加任何属性）、
• 2、赋值变量值产生新的对象
• 3、传递参数：所有函数参数都是按值传递的，把函数外部的值赋值给函数内部的参数，就和把值复制到另一个变量一样
• 4、检测类型：
  • typeof 操作符是确定一个变量是字符串、数值、布尔值，还是 undefined 的最佳工具
  • 如果要知道是什么类型的对象用instance of，如果给定的是引用类型的实例该操作符会返回true，所有引用类型的值都是object的实例（检测基本类型会返回false）

result = variable instanceof constructor
alert(person instanceof Object);  // 变量 person 是 Object 吗？
alert(colors instanceof Array); // 变量 colors 是 Array 吗？
alert(pattern instanceof RegExp); // 变量 pattern 是 RegExp(正则表达式) 吗？

• 执行环境与作用域
  • 全局执行环境被认为是 window 对象，因此所有全局变量和函数都是作为 window 对象的属性和方法创建的代码在程序的任何地方都能被访问，window 对象的内置属性都拥有全局作用域。
  • 当代码在一个环境中执行时，会创建变量对象的一个作用域链，但是函数创建的时候就已经确定了作用域，作用域链保证对环境有权访问的所有变量和函数的有序访问
    

如果这个环境是函数，则将其活动对象（activation object）作为变量对象。活动对象在最开始时只包含一个变量，即 arguments 对象（这个对象在全局环境中是不存在的）。作用域链中的下一个变量对象来自包含（外部）环境，而再下一个变量对象则来自下一个包含环境。这样，一直延续到全局执行环境；全局执行环境的变量对象始终都是作用域链中的最后一个对象

+  意思就是：一般情况下，变量取值到 创建 这个变量 的函数的作用域中取值。但是如果在当前作用域中没有查到值，就会向上级作用域去查，直到查到全局作用域，这么一个查找过程形成的链条就叫做作用域链。

• 延长作用域链：
• 1、对 with 来说，将会指定对象添加到作用域链中。将特定的变量对象保存在作用域链的最上层
  • with: 一般的，“由于with语句块中作用域的‘变量对象’是只读的，所以在他本层定义的标识符，不能存储到本层，而是存储到它的上一层作用域”。

var o={href:"sssss"};  
var href="1111";  
function buildUrl(){  
     var qs="?debug=true";       
     with(o){  
          href="2222";  
          var url=href+qs;  
     }      
     return url;  
}  
var result=buildUrl();  
alert(result);  
alert(href);//结果：2222?debug=true  +  1111

1. with中首先查找的是相关对象的属性，如果没有，才改变变量的值
   2.使用即时调用函数来替代with语句(性能不好)，通过函数传参的方式使用更短的引用来替代冗长的引用前缀比使用with语句消除前缀的方式更好

• 2、对 catch 来说，会创建一个新的变量对象，其中包含的是被抛出的错误对象的声明。

try{
adda}

在catch(err){}中的错误对象组成了一个新的变量对象然后被加到了作用域的最前端

• 没有块级作用域：

for (var i=0; i < 10; i++){
doSomething(i);
}
alert(i); //10

使用 var 声明的变量会自动被添加到最接近的环境

function add(num1, num2) {
var sum = num1 + num2;
return sum;
}
var result = add(10, 20); //30
alert(sum); //由于 sum 不是有效的变量，因此会导致错误

• 查询表示符
  • 从作用域链的前端开始，向上逐级查询与给定名字匹配的标识符

  所以访问局部变量就更快，不用向上搜索作用域链

• 垃圾收集
  • 会负责管理代码执行过程中使用的内存
  • 标记清除(两个栈标记为重复的栈)
  • 引用计数（很像树的后序遍历）

第五章（引用类型）

• 概念：引用类型是一种数据结构用于将功能和概念组织在一起（描述一类对象所具有的属性和方法）
  • 对象是某个特定引用类型的实例
• Object类型
  • 两种创建Object实例的方式
    • 1、new+Object构造函数
    • 2、对象字面量(不会调用Object构造函数)

var person = new Object();
person.name = "Nicholas";
person.age = 29;


var person = {
name : "Nicholas",
age : 29
};

• 访问属性的两种方式：

alert(person["name"]);
alert(person.name); 

方括号可以通过变量来访问属性var propertyName = "name"; alert(person[propertyName]); //"Nicholas"
如果属性名中包含会导致语法错误的字符，或者属性名使用的是关键字或保留字，也可以使用方括号表示法

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

• Array类型

  • 数组的每一项可以保存任何类型的数据
  • 创建数组两种方式：
    • 1、new(可省略)+Array函数
    • 2、数组字面量

var colors = new Array(20);
var colors = new Array("red", "blue", "green");
var colors = Array(3); // 创建一个包含 3 项的数组
var names = Array("Greg"); // 创建一个包含 1 项，即字符串"Greg"的数组
var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组

数组的length属性不是只读的，如果people.length本来是3，写成2或者4，会向数组移除或者添加新项

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
colors[99] = "black"; // （在位置 99 ）添加一种颜色
alert(colors.length); // 100

• 检测数组：instance of
• 转换方法：返回字符串toLocaleString(),toString,返回数组valueOf()默认情况下都是以,分割

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
alert(colors.toString()); // red,blue,green
alert(colors.valueOf()); // red,blue,green
alert(colors); // red,blue,green

• 小插曲：.split方法分割字符串：该方法和python中的有差别，并不是直接以那个符号进行分割而是以那个符号为参考
• stringObject.split(separator,howmany)

1、 separator 必需。字符串或正则表达式，从该参数指定的地方分割 stringObject
2、howmany 可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。

document.write(str.split(" ") + "<br />")//How,are,you,doing,today?
document.write(str.split("") + "<br />")//H,o,w, ,a,r,e, ,y,o,u, ,d,o,i,n,g, ,t,o,d,a,y,?
document.write(str.split(" ",3))//How,are,you

• join方法(与上面的方法比起来可以设置其他的分隔符)
  • var colors = ["red", "green", "blue"]; alert(colors.join(",")); //red,green,blue alert(colors.join("||")); //red||green||blue
• 栈方法

var colors = ["red", "blue"];
colors.push("brown"); // 添加另一项
colors[3] = "black"; // 添加一项
alert(colors.length); // 4
var item = colors.pop(); // 取得最后一项
alert(item); //"black"

• 队列（末端添加项：push;前端取得项：shift;前端添加任意项：unshift）

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

• 重排序方法
  • reverse():反转顺序
  • sort():按升序排列（参数可以是函数，插入排序和快速排序）

  这两个方法会返回排好序的数组

• 操作方法
  • concat()方法：可以基于当前数组的所有项创建一个新数组并且返回（所以没有传参只是复制）,也可以传数组
  • slice():两个参数，返回项的起始位置和结束位置==（伪数组）==
  • splice(),返回被删除的，会修改原数组
    • 删除： splice(0,2) 会删除数组中的前两项。
    • 插入： 3 个参数：起始位置、0（要删除的项数）
      和要插入的项splice(2,0,“red”,“green”) 会从当前数组的位置 2 开始插入字符串 “red” 和 “green”
    • 替换： 3 个参数：起
      始位置、要删除的项数和要插入的任意数量的项

var colors = ["red", "green", "blue"];
var colors2 = colors.concat("yellow", ["black", "brown"]);
alert(colors); //red,green,blue
alert(colors2); //red,green,blue,yellow,black,brown

var colors = ["red", "green", "blue", "yellow", "purple"];
var colors2 = colors.slice(1);
var colors3 = colors.slice(1,4);
alert(colors2); //green,blue,yellow,purple
alert(colors3); //green,blue,yellow

• 位置方法:
  • indxOf():从开头开始找
  • lastIndexOf()：从末尾开始找

这两个方法都接收
两个参数：要查找的项和（可选的）表示查找起点位置的索引

var person = { name: "Nicholas" };
var people = [{ name: "Nicholas" }];
var morePeople = [person];
alert(people.indexOf(person)); //-1
alert(morePeople.indexOf(person)); //0

• 迭代方法
  • 1、every() ：对数组中的每一项(和some的区别)运行给定函数，（回调检测）如果该函数对每一项都返回 true ，则返回 true
  • 2、filter() ：对数组中的每一项运行给定函数，返回该函数会返回 true 的项组成的数组
  • 3、forEach() ：对数组中的每一项运行给定函数。这个方法没有返回值。对数组中的每一项运行传入的函数本质上与使用 for 循环迭代数组一样
  • 4、 map() ：对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。
  • 5.some对数组中的每一项运行给定函数，如果该函数对任一项返回 true ，则返回 true 。

每个方法都接收两个参数：要在每一项上运行的函数和（可选的）运行该函数的作用域对象——影响 this 的值以上方法都不会修改数组中的包含的值。

var numbers = [1,2,3,4,5,4,3,2,1];
var mapResult = numbers.map(function(item, index, array){
return item * 2;
});
alert(mapResult); //[2,4,6,8,10,8,6,4,2]

• 归并方法（这两个方法都会迭代数组的所有项，然后构建一个最终返回的值）

  • 1.reduce():从第一项开始

  • 2.reduceRight():从最后一项开始（感觉像递归的前一阶段）
    

  • 2只是从后向前加

 reduce() 对于空数组是不会执行回调函数的

• 两个方法都是传俩参，具体见图

Date类型

• 创建日期对象（使用 new 操作符和 Date 构造函数）
  • var now = new Date();
• Date.parse() 方法接收一个表示日期的字符串参数，然后尝试根据这个字符串返回相应日期的毫秒数

var someDate = new Date(Date.parse("May 25, 2004"));//为2004年5月25日创建一个日期对象

• Date.UTC() 方法同样也返回表示日期的毫秒数，参数：与 Date.parse() 在构建值时使用不同的参数Date.UTC() 的参数分别是年份、基于 0 的月份（一月是 0，二月是 1，以此类推）、月中的哪一天（1 到 31）、小时数（0 到 23）、分钟、秒以及毫秒数（只有前两个参数时必须的）
• Data.now() 方法，返回表示调用这个方法时的日期和时间的毫秒数
• 日期格式化方法

RegExp类型

• 每个正则表达式都可以带有一或多个标志用以表明正则表达式的行为
• 三个标志
  • g ：(global)表示全局模式
  • i ：(case-insensitive)表示不区分大小写模式
• m ：(multiline)表示多行模式

1、一个正则表达式就是一个模式与上述三个标志的组合体
2、所有元字符必须转义包括：( [ { \ ^ $ | ) ? * + . ] }

• 创建正则表达式：
  • 1、字面量
  • 2、RegExp（）构造函数：两个参数，一个是要匹配的字符串模式，一个是可选的标志字符串(所有元字符要进行双重转义)

var pattern1=/[bc]at/i;
var pattern2=new RegExp("[bc]at","i")//二者都是匹配第一个bat或者cat

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

var pattern1 = /\[bc\]at/i;
alert(pattern1.global); //false
alert(pattern1.ignoreCase); //true
alert(pattern1.multiline); //false
alert(pattern1.lastIndex); //0
alert(pattern1.source); //"\[bc\]at"

var pattern2 = new RegExp("\\[bc\\]at", "i");
alert(pattern2.source); //"\[bc\]at"

• RegExp实例方法
  • 1、 exec()方法：接受一个参数即待匹配的字符串，返回包含第一个匹配项信息的数组，且该数组有两个额外的属性（index和input）
    • index:匹配项在字符串中的位置
    • input:应用正则表达式的字符串

在数组中，第一项是与整个模式匹配的字符串，其他项是与模式中的捕获组匹配的字符串

var text = "mom and dad and baby";
var pattern = /mom( and dad( and baby)?)?/gi;
var matches = pattern.exec(text);
alert(matches.index); // 0
alert(matches.input); // "mom and dad and baby"
alert(matches[0]); // "mom and dad and baby"
alert(matches[1]); // " and dad and baby"
alert(matches[2]); //" and baby"   模式包含两个捕获组。最内部的捕获组匹配 "and baby" 而包含它的捕获组匹配 "and dad" 或者 "and dad and baby"

1、在不设置全局标志g时：在同一个字符串上多次调用exec()始终返回第一个匹配项的信息
2、设置全局标志情况下，每次调用exec()就会在字符串中查找新的匹配项直至搜索到字符串末尾

• 2、test()方法：接受一个字符串参数，在模式与该参数匹配时返回true否则false(验证用户输入)
• RegExp 实例继承的toLocaleString() 和 toString() 方法都会返回正则表达式的字面量与创建方式无关

var pattern = new RegExp("\\[bc\\]at", "gi");
alert(pattern.toString()); // /\[bc\]at/gi
alert(pattern.toLocaleString()); // /\[bc\]at/gi

• RegExp构造函数属性

第五章其余内容（函数）

Function类型

• 由于函数是对象，因此函数名实际也是一个指向函数对象的指针不会与某个函数绑定
• 三种创建函数的方式（第三种不支持）

function sum(num1,num2){
return num1+num2;
}
var sum=function(num1,num2){
return num1+num2;
};//注意分号
var sum=new Function("num1","num2","return num1+num2")

函数是对象，函数名是指针

• 没有重载
  • 因为函数名相当于指针

function add(num){
return num+100;}
function add(num){
return num+200;
}
var result=add(100);//300 后面的函数会覆盖前面的函数

以上代码和下面的等价（便于理解）

//函数表达式声明
var add=function(num){
return num+100;};
//直接声明
add=function(num){
return num+200;};
var result=add(100);//300

• 函数声明与函数表达式
  • 解析器会率先读取函数声明并使其在执行任何代码之前可用，而函数表达式要等到解析器执行到它所在的代码行js引擎在第一遍会声明函数并将它们放到源代码树的顶部，即使声明在调用后面也能提升，但是改写为函数表达式声明就会报错

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

在代码执行之前解析器就已经通过一个函数声明提升的过程，将函数声明添加到执行环境中

• 要注意用var 方式声明的函数只能在声明之后被调用，因为它是在函数运行的阶段赋值给add的
• 而直接用function声明的函数可以在作用域任一个地方调用，因它是在函数解析阶段赋值给add的
• 值得注意的是当同时使用这两种方法声明同一个函数名，最终执行的是(函数表达式声明的函数)(var)

使用不带（）的函数名是访问函数指针而非调用函数，与C语言一样赋值表示指针指向的赋予

• 作为值的函数
  • 函数名本身就是变量，所以函数也可以作为值来使用，传参时可以传函数也可以返回一个函数第二个参数是前一个函数的参数

function add10(num){
return num + 10;
}
var result1 = callSomeFunction(add10, 10);//第二个10是add的参数，第一个是函数名字，即访问函数指针但不执行函数
alert(result1); //20

没看懂下面的例子

> function createComparisonFunction(propertyName) {
return function(object1, object2){
var value1 = object1[propertyName];
var value2 = object2[propertyName];
if (value1 < value2){
return -1;
} else if (value1 > value2){
return 1;
} else {
return 0;
}
};
}

函数内部属性

• arguments和this
  • arguments是一个类数组对象，包含着传入参数中的所有参数这也是他的主要作用，有一个callee的属性（一个指针），指向拥有这个arguments对象的函数
    • callee可以解除函数的执行和函数名紧密耦合的情况

function fun(num){
if (num <=1) {
return 1;
} else {
return num * arguments.callee(num-1)//指针指向这个函数
}  // return num *fun(num-1)
}

在上面的情况中如果用callee属性就可以无论函数名是什么都能保证正常的递归调用（下个例子更能明显体现）

var fun2= factorial;
fun= function(){
return 0;
};
alert(fun2(5)); //120
alert(fun(5)); //0

此时fun2能正常计算阶乘但是fun变成了一个只能返回0的函数

• this

this引用的是函数据以执行的环境对象当在网页的全局作用域中调用函数时this对象引用的就是window

• caller属性：保存着调用当前函数的函数的引用

function outer(){
inner();
}
function inner(){
alert(inner.caller);
alert(arguments.callee.caller);//第二句和第一句功能一样，但是第二句能实现更松散的耦合
}
outer();//此时inner.caller指向outer()

不能为caller赋值

函数属性和方法

• 属性：
  • length:表示函数希望接收的命名参数的个数
  • prototype:

  对于引用类型而言， prototype 是保存它们所有实例方法的真正所在诸如toString() 和 valueOf() 等方法实际上都保存在 prototype 名下，只不过是通过各自对象的实例访问该属性是不可枚举的

• 方法：两个方法的用途都是在特定的作用域中调用函数，实际上等于设置函数体内 this 对象的值
  • apply():两个参数，一个
    是在其中运行函数的作用域，另一个是参数数组第二个参数可以是 Array 的实例，也可以是arguments 对象

function sum(num1, num2){
return num1 + num2;
}
function callSum1(num1, num2){
return sum.apply(this, arguments); // 传入 arguments 对象
}
function callSum2(num1, num2){
return sum.apply(this, [num1, num2]); // 传入数组
}
alert(callSum1(10,10)); //20
alert(callSum2(10,10)); //20

• call():与apply方法的作用相同只是接收参数方式不同，不确定参数，第一个仍然是this值，后面传递给函数的参数必须逐个列举出来

function sum(num1, num2){
return num1 + num2;
}
function callSum(num1, num2){
return sum.call(this, num1, num2);//2个参数要逐一列举
}
alert(callSum(10,10)); //20

这两个方法能扩充函数的作用域：

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，此时this指向了o

如果不用这个方法的话要将saycolor函数放进对象o中

var o = { color: "blue" };
function sayColor(){
alert(this.color);
}
sayColor(); //"red"
o.sayColor = sayColor;//将函数放进o对象中
o.sayColor(); //"blue"

因此用方法来扩充作用域的最大好处就是对象不需要与方法有任何耦合关系

基本包装类型（Boolean/Number/String）

每读取一个基本类型值的时候回创建一个对应的基本包装类型的对象，它们是基本类型值，但是在读取模式中访问时：（例如string）
(1) 创建 String 类型的一个实例；
(2) 在实例上调用指定的方法；
(3) 销毁这个实例。

• 引用类型与基本包装类型的主要区别就是对象的生存期。自动创建的基本包装类型的对象，则只存在于一 行代码的执行瞬间，然后立即被销毁。这意味着我们不能在运行时为基本类型值添加属性和方法

var s1 = "some text";
s1.color = "red";
alert(s1.color); //undefined

• 因为第二行创建的string对象在执行第三行代码的时候已经销毁了第三行又创建了自己的string对象而此时的这个对象没有color属性

• Object 构造函数也会像工厂方法一样，根据传入值的类型返回相应基本包装类型的实例：

var obj = new Object("some text");
alert(obj instanceof String); //true

• 把字符串传给 Object 构造函数，就会创建 String 的实例

Booolean

var falseObject = new Boolean(false);
var result = falseObject && true;
alert(result); //true
var falseValue = false;
result = falseValue && true;
alert(result); //false

示例中的这行代码是对falseObject 而不是对它的值进行求值。布尔表达式中的所有对象都会被转换为 true

Number

注意一点：可以为toString方法穿第一个表示基数的参数告诉他返回几进制数值的字符串形式

var num = 10;
alert(num.toString()); //"10"
alert(num.toString(2)); //"1010"

• toFixed():var num = 10;
  alert(num.toFixed(2)); //“10.00”
• toExponential():var num = 10;
  alert(num.toExponential(1)); //“1.0e+1”
• toPrecision():var num = 99;
  alert(num.toPrecision(1)); //“1e+2”
  alert(num.toPrecision(2)); //“99”
  alert(num.toPrecision(3)); //“99.0”

String

• 字符方法：
  • charAt()
  • charCodeAt()
  • [索引]
• 操作方法
  • concat:用于将一个或多个字符串拼接返回拼接得到的新字符串，可以接受任意多个参数
  • slice()
  • substr()
  • substring()：与上面2个不同的是第二个参数是要返回的字符个数

  这三个方法都返回被操作字符串的一个子字符串，而且也都接受一或两个数。第一个参数指定子字符串的开始位置，第二个参数表示子字符串到哪里结束如果没有给这些方法传递第二个参数，则将字符串的长度作为结束位置

var stringValue = "hello world";
alert(stringValue.slice(-3)); //"rld"
alert(stringValue.substring(-3)); //"hello world"
alert(stringValue.substr(-3)); //"rld"
alert(stringValue.slice(3, -4)); //"lo w"
alert(stringValue.substring(3, -4)); //"hel"
alert(stringValue.substr(3, -4)); //"" （空字符串）

• 位置方法
  • indexOf()
  • lastIndexOf()

var stringValue = "hello world";
alert(stringValue.indexOf("o")); //4
alert(stringValue.lastIndexOf("o")); //7

• trim():会创建一个字符串的副本，删除前置及后缀的所有空格，然后返回结果
• 大小写转换
  • toLowerCase()
  • toLocaleLowerCase()
  • toUpperCase()
  • toLocaleUpperCase()

var stringValue = "hello world";
alert(stringValue.toLocaleUpperCase()); //"HELLO WORLD"
alert(stringValue.toUpperCase()); //"HELLO WORLD"
alert(stringValue.toLocaleLowerCase()); //"hello world"
alert(stringValue.toLowerCase()); //"hello world"

• 模式匹配方法

  • match()
  • search()
  • replace()

• localeCompare()：

• 根据字母表位置进行字符串的比较返回-1,0,1

var stringValue = "yellow";
alert(stringValue.localeCompare("brick")); //1
alert(stringValue.localeCompare("yellow")); //0
alert(stringValue.localeCompare("zoo")); //-1

• formCharCode()；

alert(String.fromCharCode(104, 101, 108, 108, 111)); //"hello"

单体内置对象：不依赖宿主环境的对象（Global/Match）

• Global:

不属于任何其他对象的属性和方法，最终都是它的属性和方法。事实上，没有全 局变量或全局函数；所有在全局作用域中定义的属性和函数，都是 Global 对象的属性。

• uri编码方法
• eval():只接受一个参数，即要执行的js字符串

1、eval() 中创建的任何变量或函数都不会被提升，因为在解析代码的时候，它们被包含在一个字符串中；它们只在 eval() 执行的时候创建
2、该方法只接受原始字符串作为参数，如果 string 参数不是原始字符串，那么该方法将不作任何改变地返回。因此不要为 eval() 函数传递 String 对象来作为参数。

• window对象

JavaScript中的window对象扮演ECMAScript中的Global对象，所以Global对象包含着window对象

• math对象：为保存数学公式和信息提供的一个公共位置
  • min()/max()
  • 舍入（小数->整数）
  • random()

在所有代码执行之前，作用域中就已经存在两个内置对象： Global 和 Math 。在大多数 ECMAScript
实现中都不能直接访问 Global 对象；不过，Web 浏览器实现了承担该角色的 window 对象。全局变量和函数都是 Global 对象的属性