JS變量+做用域

時間 2020-01-03

原文原文鏈接

基本類型-棧內存javascript

保存基本類型的變量保存的是值自己html

引用類型-堆內存java

保存引用類型的變量保存的並非對象自己，而是一個指向該對象的引用地址數組

引用類型判斷對象是否相等函數

    function equalObjs(a, b) {
        for (var p in a) {
            if (a[p] !== b[p]) return false;
        }
        return true;
    }
    console.log(equalObjs(xm, xh));

引用類型判斷數組是否相等spa

    function equalArrays(a, b) {
        if (a.length !== b.length) return false;
        for (var i = 0; i < a.length; i++) {
            if (a[i] !== b[i]) return false;
        }
        return true;
    }

引用類型對象複製（淺拷貝：只拷貝一層）3d

    function copyObj(obj) {
        var newObj = {};
        for (var p in obj) {
            newObj[p] = obj[p];
        }
        return newObj;
    }

console.log(undefined==null); /*true*/
console.log(undefined===null); /*false*/

從一個變量向另外一個變量複製引用類型的值，複製的實際上是指針，所以兩個變量最終都指向同一個對象，當給變量賦新值時，此變量就再也不指向原來的對象了；指針

數組是引用類型的 , 如題中b=a至關於a與b指向同一個地址 , 可是a=[4,44]以後改變了a的地址 , 因此b不會受到影響爲[4] . 後面又把a=b指向了同一個地址 ,此時爲b添加元素 , 由於a、b的地址都沒有改變 ,a也會隨之改變 ,因此a爲[4,44] . code

參數傳遞的本質是值的複製，因爲person是引用類型，這裏就至關於把person的地址複製給了函數setName的參數objhtm

    function setName(obj) {
        obj.name = 'xm';
        obj = {};
        obj.name = 'xh';
    }
    var person = {};
    setName(person);
    console.log(person.name); /*xm*/
    obj = person

檢測變量類型typeof

    console.log(typeof 4);//number
    console.log(typeof(4));//number
    console.log(typeof 'str');//string
    console.log(typeof true);//boolean
    console.log(typeof undefined);//undefined
    console.log(typeof null);//object
    console.log(typeof []);//object
    console.log(typeof {});//object
    console.log(typeof function () {});//function
    console.log(typeof /a/);//object

instanceof檢測引用類型

不能檢測基本數據類型，只要是基本數據類型和instanceof連用，返回的都是false

    console.log([] instanceof Array);//true
    console.log([] instanceof Object);//true
    console.log({} instanceof Object);//true
    console.log({} instanceof Array);//false
    console.log(1 instanceof Number);//false
console.log(null instanceof Object);//false

有兩個變量，分別是a = {name: 'xm'}, b = [4]，咱們不用第三個變量來調換a和b的值

    var a = {name: 'xm'}, b = [4];
    a=[a,b];
    b=a[0];
    a=a[1];

做用域與解析機制

全局變量容易被污染，少用

with(obj)能夠延長做用域鏈，但不推薦使用

    var person = {};
    person.name = 'xm';
    person.sex = 'male';
    var score = 4;
    
    with(person) {
        name = 'xh';
        sex = 'female';
        score = 44;
    }
    console.log(person.name);
    console.log(person.sex);
    console.log(score);

有3個按鈕給每一個按鈕添加點擊事件，但願每次點擊時輸出當前點擊的是第幾個按鈕，可是目前不論點擊哪一個按鈕，最終輸出的都是4

緣由：因爲先綁定，後觸發，給每一個按鈕綁定事件，可是在觸發的時候i已是循環完以後，i的值了

（1）單擊方法致使的循環問題。提示：單擊方法在循環外面定義

（2）在循環中調用，並將被點的按鈕的型號傳進去

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>變量、做用域</title>
    
</head>
<body>
    <button>1</button>
    <button>2</button>
    <button>3</button>
    <script type="text/javascript">
        // 錯誤代碼
        var btns = document.getElementsByTagName('button');
            for (var i = 0; i < 3; i++) {
                btns[i].onclick = function () {
                alert(i + 1);
            };
        }

        //正確代碼
        var btns = document.getElementsByTagName('button');
        var fn=function(i){
            btns[i].onclick=function(){
                alert(i+1);
            }
        }
        for(var i=0;i<btns.length;i++){
            fn(i);
        }
    </script>
</body>
</html>

不存在的變量或函數會報錯；不存在的屬性或方法，返回undefined；||是短路操做，形如a||b，若是a的值轉換成布爾值是true的話，a||b等於a；若是a的值轉換成布爾值是false的話，a||b等於b

        console.log(person||(person='xm'));
        console.log(window.person||(window.person='xm'));

預解析

1. 以var 聲明的變量會預解析，賦值爲undefined；沒有var則不進行預解析
2. 以let 聲明的變量不會進行預解析
3. 函數的聲明會預解析 , 函數會被提高，而後從上到下執行代碼的時候，輸出fn，就是提高的函數
4. 函數表達式不進行預解析

案例1：

（1）預解析：外層查找var，name和age爲undefined

（2）預解析：內層函數fn，函數在預解析時，已經提早進行了該函數的聲明。函數內變量argument、name、age爲undefined

（3）正常執行：外層name從undefined變爲’xm’，age從undefined變爲18

（4）正常執行：內層輸出name爲undefined

（5）正常執行：內層name從undefined變爲’xh’，age從undefined變爲10

    var name = 'xm';
    var age = 18;
    function fn(argument) {
        console.log(name); //undefined
        var name = 'xh';
        var age = 10;
    }
    fn();

若是預解析時變量名與函數名重複，那麼只預解析函數

案例2：

    console.log(a);
    var a = 1;/*var預解析以後是undefined*/

案例3：

    console.log(a);
    a = 1;/*沒有預解析，報錯*/

案例4：

    console.log(a); //預解析結果a()
    var a = 1;
    console.log(a); //正常賦值後執行1
    function a() {
        console.log(2); //函數在預解析以後再也不解析
    }
    console.log(a); //1
    var a = 3;
    console.log(a); //3
    function a() {
        console.log(4);
    }
    console.log(a); //3
    a(); //報錯，此時a=3，不是函數

案例5：

函數內部沒有var，不進行預解析。輸出時查找外層a，輸出1；賦值時對外層a進行操做

    var a = 1;
    function fn() {
        console.log(a);
        a = 2;//修改全局變量a
    }
    fn();
    console.log(a);

案例6：

函數參數也至關於var定義的局部變量，預解析爲undefined。賦值時對參數a進行操做

    var a = 1;
    function fn(a) {
        console.log(a);
        a = 2;/*對參數a進行操做，從undefined變爲2，全局變量a沒有改變*/
    }
    fn();
    console.log(a);

案例7：

函數參數也至關於var定義的局部變量，預解析爲undefined。賦值時對參數a進行操做

    var a = 1;
    function fn(a) {
        console.log(a);//將全局變量賦值給參數，所以參數輸出1
        a = 2;//將參數從1變成2，全局變量沒有改變
    }
    fn(a);//執行時將全局變量a=1傳入參數
    console.log(a);//1

垃圾收集機制

解除變量引用的方法是將其設置爲null