JS變量+做用域

基本類型-棧內存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

相關文章
相關標籤/搜索