块语句可以组合0~多个语句，块语句用一对花括号定义，但是在实际开发中通常不会单独用块语句，而会和if,while等结合使用。

JS中没有块级作用域！！！有函数作用域、全局作用域等。

常见误区：var a=b=1;虽然能达到给a,b都赋值为1，但是此时b是一个全局作用域，最好不要使用这种方法,在一个语句中定义多个变量，可以使用逗号隔开的方法，例如var a=1,b=1;

JS中this的四种用法

1.在一般函数方法中使用 this 指代全局对象

function test(){
　　　　this.x = 1;
　　　　alert(this.x);
　　}
　　test(); // 1

2.作为对象方法调用，this 指代上级对象

function test(){
　　alert(this.x);//这时的this指代的是对象o，
　　                即this.x指的是对象o中x的值
}var o = {};
o.x = 1;
o.m = test;
o.m(); // 1

3.作为构造函数调用，this 指代new 出的对象

　　function test(){
　　　　this.x = 1;
　　}
　　var o = new test();
　　alert(o.x); // 1
    //运行结果为1。为了表明这时this不是全局对象，我对代码做一些改变：　　var x = 2;
　　function test(){
　　　　this.x = 1;
　　}
　　var o = new test();
　　alert(x); //2

4.apply 调用 ，apply方法作用是改变函数的调用对象，此方法的第一个参数为改变后调用这个函数的对象，this指代第一个参数

　　var x = 0;
　　function test(){
　　　　alert(this.x);
　　}
　　var o={};
　　o.x = 1;
　　o.m = test;
　　o.m.apply(); //0//apply()的参数为空时，默认调用全局对象。因此，这时的运行结果为0，证明this指的是全局对象即this.x是指全局变量x的值而不是对象o中x的值。如果把最后一行代码修改为　　o.m.apply(o); //1

运算符分类：

1，一元运算符（+，-，void），二元运算符，三元运算符（c?a:b;）

老师解释说：一元运算符+，-（+尝试把一个变量转换成数字，-是把正数变负数，把负数变正数）.

通过查阅资料得：一元加运算符 (+) 的结果是其操作数的值。  一元加运算符的操作数必须是一个算术类型。整型提升是对整型操作数执行的。  结果类型是操作数将提升到的类型。  因此，表达式 +ch（其中 ch 的类型为 char）的结果类型为 int；值不会进行修改。

2，普通运算符：赋值、比较、位、逻辑、字符串拼接、算术

 特殊运算符：条件运算符、逗号运算符、delete、in、instanceof、new、this、typeof、void

注：逗号运算符，例如（1,2,3*8）会从左到右依次计算表达式的值，但    是那么最后会取最右边的即（1,2,3*8）的值位24

表达式是指能计算出值的任何可用程序单元。

函数表达式可以分为:原始表达式（number,string,关键字、变量）、数组/对象初始化表达式、函数表达式、属性访问表达式、调用表达式、对象创建表达式。

这一节中，我被对象创建惊呆了，竟然一个对象可以用户直接字定义属性，比如：var obj=new Object();

                  obj.x=1;

                  obj.y=5;

这样是合法的，在之前学过的语言中还没有遇到过这种，通常情况下，需要根据已有的类（内置的类或自己创建的类都可以）去创建对象，对象也只能访问该对象已有的属性，JS中竟然可以随意（捏造）出一个属性，直接使用，这种看起来很方便，但是应该也会有麻烦，比如可能使用不当会用得乱七八糟。

本节介绍了物种数据类型检测的方法：

typeof,instanceof,Object.prototype.toString.apply(),duck type等。

typeof:适合基本数据类型、函数数据类型，且对null失效；

instanceof:适合对象数据类型，但是它会在不同的window和iframe间检测失效；

toString：适合基本数据类型和内置对象，但是遇到null和undefined会失效；

修改属性标签

删除的数组的某一项

splice(index,len,[item])    注释：该方法会改变原始数组。

splice有3个参数，它也可以用来替换/删除/添加数组内某一个或者几个值

index:数组开始下标        len: 替换/删除的长度       item:替换的值，删除操作的话 item为空

如：arr = ['a','b','c','d']

删除

arr.splice(1,1)   //['a','c','d'] 删除起始下标为1，长度为1的一个值，len设置的1，如果为0，则数组不变

arr.splice(1,2)  //['a','d'] 删除起始下标为1，长度为2的一个值，len设置的2

替换

arr.splice(1,1,'ttt')        //['a','ttt','c','d'] 替换起始下标为1，长度为1的一个值为‘ttt’，len设置的1

arr.splice(1,2,'ttt')        //['a','ttt','d'] 替换起始下标为1，长度为2的两个值为‘ttt’，len设置的1

添加 ----  len设置为0，item为添加的值

arr.splice(1,0,'ttt')        //['a','ttt','b','c','d'] 表示在下标为1处添加一项'ttt'

2：delete      

delete删除掉数组中的元素后，会把该下标出的值置为undefined,数组的长度不会变

如：delete arr[1]  //['a', ,'c','d'] 中间出现两个逗号，数组长度不变，有一项为undefined

 两种实现方式：

1.splice：删除元素并添加新元素，直接对数组进行修改，返回含有被删除元素的数组。

      arrayObject.splice(index,howmany,element1,.....,elementX)

   index：必选，规定从何处添加/删除元素。

   howmany：必选，规定应该删除多少元素。未规定此参数，则删除从 index 开始到原数组结尾的所有元素。

   element1:可选，规定要添加到数组的新元素。

isExtensible语句的用法

概述

Object.isExtensible() 方法判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）。

语法

Object.isExtensible(obj)

参数

• obj

• 需要检测的对象

返回值

    表示给定对象是否可扩展的一个Boolean 。

描述

默认情况下，对象是可扩展的：即可以为他们添加新的属性。以及它们的 __proto__ 属性可以被更改。Object.preventExtensions，Object.seal 或 Object.freeze 方法都可以标记一个对象为不可扩展（non-extensible）。

例子

// 新对象默认是可扩展的
var empty = {};Object.isExtensible(empty); // === true
//...可以变的不可扩展.
Object.preventExtensions(empty);
Object.isExtensible(empty); // === false
// 密封对象是不可扩展的.
var sealed = Object.seal({});
Object.isExtensible(sealed); // === false
// 冻结对象也是不可扩展.
var frozen = Object.freeze({});
Object.isExtensible(frozen); // === false

注意

在 ES5 中，如果参数不是一个对象类型，将抛出一个 TypeError 异常。在 ES6 中， non-object 参数将被视为一个不可扩展的普通对象，因此会返回 false 。

Object.isExtensible(1);
// TypeError: 1 is not an object (ES5 code)

Object.isExtensible(1);
// false                         (ES6 code)

 * 不允许使用with

* 不允许为声明的变量被赋值

* argument变为参数的静态副本

* delete不可配置的属性报错

* 对象字面量重复属性名会报错

* 禁止八进制的字面量

* eval,arguments 变为关键字，不能作为变量、函数名

* eval 独立作用域

JavaScript中对象的property有三个属性：
1.writable。该property是否可写。
2.enumerable。当使用for/in语句时，该property是否会被枚举。
3.configurable。该property的属性是否可以修改，property是否可以删除。

严格模式下：

①不允许使用with；

②所以的变量都必须声明；

③禁止使用八进制；

④函数中的特殊对象arguments是静态副本，而不像非严格模式那样，修改arguments或修改参数变量会相互影响；

⑤eval，arguments变为关键字，不能作为变量名，函数名等。

for .. in 语句的用法:、

For...In 声明用于对数组或者对象的属性进行循环/迭代操作。

　　对于数组 ，迭代出来的是数组元 素，对于对象 ，迭代出来的是对象的属性；

Js代码  

1. var x  

2. var mycars = new Array()  

3. mycars[0] = "Saab"  

4. mycars[1] = "Volvo"  

5. mycars[2] = "BMW"  

6.   

7. for (x in mycars)  

8. {  

9.     document.write(mycars[x] + "<br />")  

10. }   

输出为：

1. Saab  

2. Volvo  

3. BMW  

 对象示例：

1. var obj = {  

2.     w: "wen",  

3.     j: "jian",  

4.     b: "bao"  

5. }  

6. for(var v in obj){  

7.   document.write(v)+"<br/>";  

8.   

9. }  

输出为：

1. w  

2. j  

3. b  

with语句的用法：

 with 语句可以方便地用来引用某个特定对象中已有的属性，但是不能用来给对象添加属性。要给对象创建新的属性，必须明确地引用该对象。  

2）语法格式  
with(object instance)  
{  
        //代码块  
}  
       有时候，在一个程序代码中，多次需要使用某对象的属性或方法，照以前的写法，都是通过:对象.属性或者对象.方法这样的方式来分别获得该对象的属性和方法，着实有点麻烦，学习了with语句后，可以通过类似如下的方式来实现：  
with(objInstance)  
{  
       var str = 属性1;  
.....  
} 去除了多次写对象名的麻烦。  

3）举例  
<script language="javascript">  
<!--  
function Lakers() {  
       this.name = "kobe bryant";  
       this.age = "28";  
       this.gender = "boy";  
}  
var people=new Lakers();  
with(people)  
{  
       var str = "姓名: " + name + "<br>";  
       str += "年龄：" + age + "<br>";  
       str += "性别：" + gender;  
       document.write(str);  
}  
//-->  
</script>  
代码执行效果如下:  
姓名: kobe bryant  
年龄：28  
性别：boy

1、typeof适合基本类型和函数对数的判断。
2、instanceof 适合判断对象类型。
3、Object.prototype.toString.apply.

一、隐式转换：巧妙用“+”和“-”规则转换类型

1、num-0：变为数值       2、num+"":变为字符串

当想要把字符串变为数值时：
字符串与数字之间的加号理解为字符串拼接“123”+65=“12365”

减号理解为运算 “123”-65=58

二、a==b 与 a===b 的区别：
1、类型相同时比较具体数值
2、类型不同时：
    1）==：尝试类型转换：
            string => number 把字符串变为数值再进行比较
            ture   => 1            把布尔值变为数值再进行比较
            false  => 0
            object => 基本类型（涉及包装类）
    2）===： 直接返回false

=:表示赋值，比如a=3;就是把3放到a里面
= =：表示等于，3= ="3";会返回true，因为浏览器内部会把字符串3变成数字3
= = =：表示严格等于，不会转换数据类型3= = ="3"，会返回false，因为不会转换他们的数据类型，数字和字符串当然就不相等了
对象和对象比较，是比较的引用，两个对象都是new出来的（新创建出来的），所以是不同的对象，不同的对象的引用是不同的，所以输出是false
只有对象和基本类型进行比较的时候，才会将对象转变成基本类型，再作比较。两个对象比较的时候是不会转成基本类型的，如：
var a = new String('hi');
var b = new String('hi');
a == 'hi';//true （先转换成基本类型再比较）
b == 'hi';//true（先转换成基本类型再比较）
但是 a ===b;// false  （比较的是引用）

数据类型：原始类型、对象类型。