内置类型
JavaScript 有七种内置类型：
• 空值（null） • 未定义（undefined） • 布尔值（ boolean） • 数字（number） • 字符串（string） • 对象（object） • 符号（symbol，ES6 中新增）
- 除对象之外，其他统称为“基本类型”。
- 我们可以用typeof 运算符来查看值的类型，它返回的是类型的字符串值。
- 有意思的是，这七种类型和它们的字符串值并不一一对应：
typeof undefined === "undefined"; // true
typeof true === "boolean"; // true
typeof 42 === "number"; // true
typeof "42" === "string"; // true
typeof { life: 42 } === "object"; // true
typeof Symbol() === "symbol"; // true ES6中新加入的类型
而在对变量执行typeof 操作时，得到的结果并不是该变量的类型，而是该变量持有的值的类型，因为JavaScript 中的变量没有类型。
你可能注意到null 类型不在此列。它比较特殊，typeof 对它的处理有问题：
typeof null === "object"; // true
正确的返回结果应该是"null"，但这个bug 由来已久，在JavaScript 中已经存在了将近二十年，也许永远也不会修复，因为这牵涉到太多的Web 系统，“修复”它会产生更多的bug，令许多系统无法正常工作。
我们需要使用复合条件来检测null 值的类型：
var a = null;
(!a && typeof a === "object"); // true
null 是基本类型中唯一的一个 “假值”（falsy 或者false-like）类型，typeof 对它的返回值为"object"。实际上，null 本身是基本类型。
- 数组也是对象。确切地说，它也是object 的一个“子类型”
- 除了undefined和null其他三个都有相应的构造器函数，分别是Number()、String()、Boolean()。通过这些可以创建出相应的对象，通过将这些基本类型封装成对象，就可以在其中继承一些有用的工作方法。
其调用分为两种形式：
1）使用new操作符调用--用于新建对象。
2）不使用new操作符调用，用于将任意符转换为基本数据类型。
操作符
| 操作符 | 相关操作 | 代码实例 |
|---|---|---|
| ++ | 自增1操作 | 当操作符后置，先返回该值，然后再递增1var a=123; var b=a++; b //123; a //124当操作符前置，先将值递增1，再返回 var a=123; var b=++a; b //124; a //124
|
| -- | 自减1操作 | 操作符后置var a=123; var b=a--; b //123; a //122操作符前置 var a=123; var b=--a; b //122; a //12
|
- 操作符优先级：！> && > || (最佳操作是使用括号)
- == 相等运算符，在该比较操作之前，两边的操作数会会被自动转换为相同的类型如：1==“1”;将返回true
而===等价运算符其幕后不存在任何形式的类型转换。此外!=存在类型转换，!==不允许类型转换 - 如果在同一个值上执行两次逻辑非运输，其结果就等于原值；
var b=!!true; b; 将返回true - 如果在一个非布尔值上执行逻辑运算，该值会在运算期间转换为布尔值：
var b="one"; !b; 将返回false;!!b;将会返回true; - 检验一个字符串中是否包含另一个字符串，可以用-1来做indexOf()结果比照（是区分大小写的）
if (s.indexOf('Couch') !== -1){.....}
注意if (s.indexOf('Couch')){.....}是不对的，因为索引值可能是0，会被转换为falsh
变量
- 变量没有类型，但它们持有的值有类型。类型定义了值的行为特征，通过typeof 的安全防范机制（阻止报错）来检查undeclared 变量，有时是个不错的办法。
- 注意当第二次设置变量时，就不需要再使用var语句了。
var n=1; n=1234; - 检查变量是否存在：
if(typeof somevar !==‘undefined’){result=‘yes’;}
变量的作用域
这是一个至关重要的问题，js语言不能为变量定义特定的块作用域，但可以定义其所属的函数域，函数外不可见。而如果该变量定义在if或for代码块中，它在代码块以外是可见的。
- 还有一点很重要，声明一个变量时没有用var语句，该变量会被默认为全局变量，在函数中的这种变量也一样，不过要访问到需要函数首先被调用过，也可以说在该函数被调用之前，这个没有var的变量是不存在的
function f(){local=2;} //local为全局变量
local； //ReferenceError: local is not defined
f(); //注意这里函数执行后，函数内的全局变量才能访问到
local； //2
注意：函数域始终优先于全局域
var a=123;
function f(){
alert(a); //undefined; a的声明会提升到函数体顶端，而赋值留在书写的位置
var a=1; //1
alert (a);
}
f() //1
函数
- function（函数）也是JavaScript 的一个内置类型，然而查阅规范就会知道，它实际上是object 的一个“子类型”。具体来说，函数是“可调用对象”，它有一个内部属性[[Call]]，该属性使其可以被调用。
函数对象中最重要的还是prototype属性；每个函数的prototype属性中都包含了一个对象（内建对象）；它只有在该函数是构造器时才会发挥作用；
每次某个函数被调用，就会有个新的执行上下文为其创建，即使是调用的自身函数，也是如此
var some_obj={
name:'Ninjia',
say: function(){
return 'I am a ' + this.name;
}
}
function F(){}
typeof F.prototype; //"object"
F.prototype = some_obj;
var obj=new F(); //----------------------------- 作为构造器
obj.say() //"I am a Ninjia"
Function 对象的方法：
函数对象中有两个非常有用的方法：call() 和 applay()，通过这两个方法我们就能让对象去借用其他对象中的方法，为己所用。这也是一种重用代码的方式，非常简单实用
call()方法：
var some_obj={
name:'Ninjia',
say: function(who){
return 'Haya ' + who + ', I am a ' + this.name;
}
}
some_obj.say('qing') //"Haya qing, I am a Ninjia"
再创建一个无方法的my_obj对象
my_obj = {name: 'zhu'};
some_obj.say.call(my_obj,'niro') // "Haya niro, I am a zhu"
实际上就是通过call的首参数修改了对象函数this的值。当say()被调用时，其中的this就被自动设置成了my_obj对象的引用，this.name返回的不再是Ninija了，call方法可以传递更多的参数apply()与call()基本相同，不同在于参数的传递形式（apply是数组传递）some_obj.apple(my_obj,['qing']);
js循环（四种）
js中有四种循环：while循环 、do-while循环、for循环、for-in循环
while循环是最为简单的一种：分为两个部分：小括号中的条件和大括号中的的代码块，仅当条件为true是代码块才会被反复执行。
var i=0;
while(i<10){
i++;
}
for 循环
打印一个5行5列的星号字符串图形
var res='\n'; //让第一个星号回行
for(var i=0; i<5; i++){
for(var j=0; j<5; j++){
res +='* '; //这里实际上是重新定义变量res，j 循环是列出一行5个星号。
}
res +='\n'; //这里是循环在每行加一个回行符。
}
返回：
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
加深理解
var res='\n'; //定义变量并让第一行换行
for(var i=0; i<10; i++){
for(var j=0; j<5; j++){
res +='*'; //这里输出的是一行5个星
}
res +='\n' + i; //这里输出的是10列，没有换行符的话就是在每5颗星后一个序列数字
}
"
*****
0*****
1*****
2*****
3*****
4*****
5*****
6*****
7*****
8*****
9"
乘法口诀：
var res='\n';
for(var i =1 ;i<=9;i++){
for(var j=1 ;j<=i;j++){ //---------------------重点j<=i
res +=(i+"*"+j+"="+(i*j)+" "); //----------核心是(i*j)
}
res +="\n";
}
for-in 循环：
往往用来遍历一某个数组或对象中的元素，下面打印出数组当前所在的位置键值和元素值
var a = ['a','b','c','d'];
var result='\n';
for(var i in a){ //
result += 'index: ' + i + ', value: ' + a[i]+ '\n';
} // ------------------------------核心只是result += a[i]
打印出：
index: 0, value: a
index: 1, value: b
index: 2, value: c
index: 3, value: d
下面将所有对象属性复制在一个数组中：
var o={x:1,y:2,z:3};
var a=[],i=0;
for(a[i++] in o); // 这里很简单，a和i上面已经声明过了结果就是a[0]、a[1]...
console.log(a) // 输出["x", "y", "z"]
location (浏览器对象模型BOM的组成部分)：
使用location对象可以通过编程方式来访问浏览器的导航系统，设置相应的属性、可以逐段或整体地 修改浏览器的URL.
如：假设初始URL为http://www.zunyang.com/okzu/
将URL修改为"http://www.zunyang.com/okzu/#sectino1"
location.hash="#sectino1";
将URL修改为"http://www.zunyang.com/okzu/zun/"
location.pathname="zun" ;
将URL修改为"http://www.zunyang.com/okzu/?q=javascript"
location.search="?q=javascript"
等等，此外还有hostname、port
HTML5 classList属性的方法
toggle、contains、add、remove
toggle 如果列表中已经存在给定的值，删除她，如果没有就添加
div.classList.toggle("myClass");
确定元素中是否包含既定的类名
if(div.classList.contains("db) && !div.classList.contains("disable")){}
删除类名remove，添加add
readyState 属性
有两个可能的值
1.loading,正在加载文档 2.complete,已经加载完文档
if(documengt.readyState == "complete"）{//执行操作}
内存与性能问题
在使用innerHTML、outerHTML属性、insertAdjacentHTML()方法时（以上都是HTML5规范），最好先手动删除要被替换元素的所有事件处理程序和JS对象属性。假设某个HTML元素有一个事件处理程序或引用了一个JS对象作为属性，将该元素从文档树中删除后，其绑定关系并没有一并删除，这种情况太多页面占用内存的数量就会明显上升。
for(i=0;len=values.length;i<len,i++){
ul.innerHTML += "<li>" + values[i] + "<li/>";
}
要避免以上的操作，因为每次循环要从innerHTML中读取信息，要像下面这样把innerHTML放在循环体外面
var itemsHTML ="";
for(i=0;len=values.length;i<len,i++){
itemsHTML += "<li>" + values[i] + "<li/>";
}
ul.innerHTML = innerHTML; //只对innerHTML执行了一次赋值操作；
Firefox 控制台设置
1.地址栏输入about:config;
2.在过滤器的搜索栏输入strict按回车；
3.双击javascript.options.strict选项所在的行，将其值改为true;
另外控制台有多行代码输入选项，一般情况下是单行，多行注意在行尾端输入“；”
