js基础知识总结篇

  javascript在学习过程中的重点易忘的部分的总结~

基本类型　　　　　　　　　　　　　　　　　　　　　

注意：　JavaScript 不区分整数值和浮点数值，所有数字在 JavaScript 中均用浮点数值表示。
　　　　０.１＋　０．２　＝　0.30000000000000004
单元运算符 + 也可以把数字字符串转换成数值
如果给定的字符串不存在数值形式，函数会返回一个特殊的值 NaN（Not a Number 的缩写）：

JavaScript 中 null 和 undefined 是不同的，前者表示一个空值（non-value），后者是“undefined（未定义）”类型的对象，表示一个还没有被分配的值
JavaScript 允许声明变量但不对其赋值，一个未被赋值的变量就是 undefined 类型。还有一点需要说明的是，undefined 是一个不允许修改的常量。

bool 变量的转换：
false、0、空字符串(“”)、NaN、null 和 undefined 被转换为 false，其他值被转换为 true；

JavaScript 与其他语言的（如 Java）的重要区别是在 JavaScript 中语句块（blocks）是没有作用域的，只有函数有作用域。
但是从 ECMAScript Edition 6 开始将有所不同的， let 和 const 关键字允许你创建块作用域的变量。

如果你用一个字符串加上一个数字（或其他值），那么操作数都会被首先转换为字符串

 "3" + 4 + 5; // 345
  3 + 4 + "5"; // 75

技巧：通过与空字符串相加，可以将某个变量快速转换成字符串类型。

对象

JavaScript 中的对象可以简单理解成“名称-值”对

var obj = {
    name: "Carrot",
    "for": "Max",
    detail:{
        color:"orange",
        size:12
    } 
}
//数组的遍历 
for(var i=0, item;item = a[i++];)
{
    //to do sth with item;
}
在5中提出了foreach来遍历数组；

function add(){
    var sum = 0;
    for(var i = 0,j = arguments.length;i < j;i++)
    {
        sum += arguments[i];
    }
    return sum;
}

console.log(obj.detail.color);
console.log(obj.for);

function add(){
    var sum = 0;
    for(var i = 0, j = arguments.length;i<j;i++){
        sum += arguments[i];
    }
    return sum;
}
console.log(add(2,3,4,5));

//块级作用域 
var a = 1;
var b = 2;
(function(){
    var b = 3;
    a += b ;
})();
console.log(a);

匿名函数的递归

匿名函数没有名字，那该怎么递归调用它呢？在这一点上，JavaScript 允许你命名这个函数表达式。
你可以命名立即调用的函数表达式
函数表达式的名称的作用域仅仅是该函数自身

//注意： JavaScript 函数是它们本身的对象——就和 JavaScript 其他一切一样——你可以给它们
//添加属性或者更改它们的属性，这与前面的对象部分一样。
var charInBody = (function counter(elm){
    if(elm.nodeType == 3){
        return elm.nodeValue.length;
    }
    var counts = 0;
    for(var i = 0,child ;child = elm.childNodes[i];i++)
    {
        counts += counter(child);
    }
})(document.body);

自定义对象

关键字 this。当使用在函数中时，this 指代当前的对象，也就是调用了函数的对象。
如果在一个对象上使用点或者花括号来访问属性或方法，这个对象就成了 this。
如果并没有使用“点”运算符调用某个对象，那么 this 将指向全局对象（global object）。

另外一个关键字：new，它和 this 密切相关。它的作用是创建一个崭新的空对象，然后使用指向那个
对象的 this 调用特定的函数。注意，含有 this 的特定函数不会返回任何值，只会修改 this 对象
本身。new 关键字将生成的 this 对象返回给调用方，而被 new 调用的函数成为构造函数。
习惯的做法是将这些函数的首字母大写，这样用 new 调用他们的时候就容易识别了。

原型链（prototype chain）的查询链的一部分：当你试图访问一个 Person 没有定义的属性时，
解释器会首先检查这个 Person.prototype 来判断是否存在这样一个属性。
所以，任何分配给 Person.prototype 的东西对通过 this 对象构造的实例都是可用的。

function Person(first , last){
    this.first = first ;
    this.last  = last ;
}
Person.prototype.fullName = function(){
    return this.first + '' +this.last;
}
Person.prototype.fullNameReversed = function(){
    return this.last + ',' + this.first;
}

//逆置
var s = "Simon";
//s.reversed();

String.prototype.reversed = function(){
    var r = "";
    for(var i = this.length-1;i>=0;i--)
    {
        r += this[i];
    }
    return r;
}
console.log(s.reversed());
console.log("abcdefghi".reversed());

//
function tricialNew(constructor , ...args){
    var o = {};
    constructor.apply(o,args);
    return o;
}

内部函数

JavaScript 允许在一个函数内部定义函数，关于 JavaScript 中的嵌套函数，
一个很重要的细节是它们可以访问父函数作用域中的变量：

function betterExampleNeeded() {
    var a = 1;
    function oneMoreThanA() {
        return a + 1;
    }
    return oneMoreThanA();
}

内部函数可以共享父函数的变量，所以你可以使用这个特性把一些函数捆绑在一起，这样可以有效地防止
“污染”你的全局空间——你可以称它为“局部全局（local global）”。

闭包

function makeAdder(a) {
    return function(b) {
        return a + b;
    }
}
x = makeAdder(5);
y = makeAdder(20);
x(6); // 返回 11
y(7); // 返回 27

每当 JavaScript 执行一个函数时，都会创建一个作用域对象（scope object），用来保存在这个函数中创建的局部变量。
它和被传入函数的变量一起被初始化。这与那些保存的所有全局变量和函数的全局对象（global object）类似，
但仍有一些很重要的区别:
第一，每次函数被执行的时候，就会创建一个新的，特定的作用域对象；
第二，与全局对象（在浏览器里面是当做 window 对象来访问的）不同的是，你不能从 JavaScript 代码中直接访问
作用域对象，也没有可以遍历当前的作用域对象里面属性的方法。

所以当调用 makeAdder 时，解释器创建了一个作用域对象，它带有一个属性：a，这个属性被当作参数传入 makeAdder 函数。
然后 makeAdder 返回一个新创建的函数。通常 JavaScript 的垃圾回收器会在这时回收 makeAdder 创建的作用域对象，
但是返回的函数却保留一个指向那个作用域对象的引用。结果是这个作用域对象不会被垃圾回收器回收，
直到指向 makeAdder 返回的那个函数对象的引用计数为零。

作用域对象组成了一个名为作用域链（scope chain）的链。它类似于原形（prototype）链一样，被 JavaScript 的对象系统使用。

一个闭包就是一个函数和被创建的函数中的作用域对象的组合。闭包允许你保存状态 ——所以它们通常可以代替对象来使用。

类这一概念在 JavaScript 通过对象原型（object prototype）得到延续
JavaScript 中的函数也是对象，JavaScript 允许函数在包含可执行代码的同时，能像其他对象一样被传递。

内存泄露

JavaScript 是一种具有垃圾回收机制的语言——对象在被创建的时候分配内存，然后当指向这个对象的引用计数为零时，
浏览器会回收内存。宿主环境提供的对象都是按照这种方法被处理的。

在 IE 中，每当在一个 JavaScript 对象和一个本地对象之间形成循环引用时，就会发生内存泄露。

function leakMemory() {
    var el = document.getElementById('el');
    var o = { 'el': el };
    el.o = o;
}

闭包很容易发生无意识的内存泄露。

function addHandler() {
    var el = document.getElementById('el');
    el.onclick = function() {
        el.style.backgroundColor = 'red';
    }
}

这段代码创建了一个元素，当它被点击的时候变红，但同时它也会发生内存泄露。为什么？
因为对 el 的引用不小心被放在一个匿名内部函数中。这就在 JavaScript 对象（这个内部函数）和本地对
象之间（el）创建了一个循环引用。
这个问题有很多种解决方法，最简单的一种是不要使用 el 变量：

function addHandler(){
    document.getElementById('el').onclick = function(){
        this.style.backgroundColor = 'red';
    };
}

有趣的是，有一种破坏因为闭包引入循环引用的窍门是添加另外一个闭包：

function addHandler() {
    var clickHandler = function() {
        this.style.backgroundColor = 'red';
    };
    (function() {
        var el = document.getElementById('el');
        el.onclick = clickHandler;
    })();
}

内部函数被直接执行，并在 clickHandler 创建的闭包中隐藏了它的内容。

ECMAScript范畴

哪些内容被纳入ECMAScript范畴中了？

ECMAScript 定义了：

语法（解析规则，关键字，流程控制，对象初始化等）
错误处理机制（throw， try/catch 以及用户自定义错误类型的能力）
类型（布尔值，数字，字符串，函数，对象等）
全局对象。在浏览器环境中，window就是全局对象，这个对象拥有很多函数（parseInt， parseFloat， decodeURI， encodeURI等）
基于原型的继承机制
内置对象和函数（JSON，Math，Array.prototype 方法，Object introspection 方法等）
严格模式