JS數據類型和堆棧+變量比較和值的複製+參數傳遞和類型檢測

時間 2020-02-11

標籤數據類型堆棧變量比較複製參數傳遞檢測欄目 JavaScript 简体版

原文原文鏈接

變量命名html

變量名：字母數字下劃線美圓符$jquery

jquery: $ $.each() $ === jQuery數組

underscore( js的一個函數庫) : _ _.each()函數

關鍵字 : if forspa

保留字 : classcode

推薦有意義的命名：htm

buttonCancel button_cancel btnCancel對象

數據類型和堆棧blog

基本類型（能夠修改） : 4 str true undefined null遞歸

引用類型（不能修改） : { } [ ]

var score = 40;
score = 50;

上面屬於覆蓋，不屬於修改

var str = "hello";
var newStr = str.replace("h", "");
document.write( str + "/" + newStr);

字符串操做返回新的字符串，原字符串沒有改變

        var obj = {};
        console.log(obj);
        obj.name = "cyy";
        obj.age = 25;
        obj.name = "cyy2";
        delete obj.age;
        console.log(obj);

引用類型的屬性能夠添加，能夠修改，能夠刪除

        var name = "cyy";
        name.age = 25;
        console.log(name.age);//undefined

基本類型不能添加屬性

str.replace()

1->Number

"str"->String

不是基本類型有屬性和方法，而是經過基本類型找到其包裝對象，包裝對象會把屬性和方法借給該基本類型的變量

基本類型保存在棧內存中，按值訪問（直接訪問）

引用類型保存在堆內存中，可是地址保存在棧內存中，按引用訪問（須要中轉）

變量比較和值的賦值

        var obj1 = {
            age: 24,
            num: 1
        }
        var obj2 = {
            age: 24,
            num: 1
        }
        console.log(obj1 === obj2);//false

基本類型的比較就是值的比較，只要值相等即爲相等

引用類型，其實是開闢了各自的內存空間，雖然內容相等，可是並非一個地址

只有當指向同一個引用的時候，才爲相等

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        var obj1 = {
            age: 24,
            num: 1
        }
        var obj2 = obj1;
        console.log(obj1 === obj2);//true
    </script>
</body>
</html>

此時obj2保存的是obj1的地址，所以相等

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        var obj1 = {
            age: 24,
            num: 1
        }
        var obj2 = {
            age: 24,
            num: 1
        }
        function equelObj(a, b){
            for(var i in a){
                if(a[i] !== b[i]) return false;
            }
            return true;
        }
        console.log(equelObj(obj1, obj2));//true
    </script>
</body>
</html>

以上方式能夠比較兩個對象的內容是否相等

        function equelArr(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;
        }

以上方式比較兩個數組的內容是否相等

var name1 = "cyy";
var name2 = name1;
console.log(name2);//cyy

name2 = "cyy2";
console.log(name1);//cyy

基本類型複製是值的複製，兩個變量互不干涉

var obj1 = {
    name: "cyy",
    age: 24
}
var obj2 = obj1;
obj2.age++;
console.log(obj2.age);//25
console.log(obj1.age);//25

引用類型複製是地址的複製，兩者指向同一個地址，一個改變另外一個也會發生改變

var obj1 = {
    name: "cyy",
    age: 24
}
function copyObj(a){
    var newObj = {};
    for(var i in a){
        newObj[i] = a[i];
    }
    return newObj;
}
console.log(copyObj(obj1));

以上方法是複製一個對象的內容，但不是引用的同一個地址

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
<script>
var obj1 = {
    name: "cyy",
    age: 24,
    hobby: []
}
function copyObj(a){
    var newObj = {};
    for(var i in a){
        newObj[i] = a[i];
    }
    return newObj;
}
console.log(copyObj(obj1));
</script>
</body>
</html>

該方式屬於淺拷貝，若是對象中某個屬性自己是引用類型，則複製時又會該屬性又會指向同一個地址，須要用到遞歸解決

jquery 中的 $.extend 既能夠進行淺拷貝，又能夠進行深拷貝

不使用新的變量，來對換兩個變量的值

var a = 3;
var b = 4;
a = a + b; //a=7
b = a - b; //b=3
a = a - b; //a=3

一個很奇葩的規則：賦值纔會改變引用的地址，可是添加與修改內容不會改變地址

var a=[4];
var b=a;//此時b與a指向同一個空間 a=[4]  b=[4]
a=[4,44];//此處a被從新賦值，指向了另外一個空間；b仍舊指向原來的空間
console.log(a);//(2) [4, 44]
console.log(b);//[4]

a=b;//此時a又指向了b的空間 a=[4] b=[4]
b.push(44);
console.log(a);//(2) [4, 44]

參數傳遞和類型檢測

function add(a,b){
    return a+b;
}
console.log(add(3,4));//7

a,b是形參，3,4是實參

function addName(obj){
    obj.name="cyy";
}
var me={};
addName(me);
console.log(me.name);//cyy

引用類型的參數傳遞（實質上也是值傳遞）

function addName(obj){
    obj.name="cyy";//me.name=cyy（值傳遞)
    obj={};//obj指向了一個新的地址，可是me依舊指向老的地址
    obj.name="cyy2";//對新的地址進行操做
}
var me={};
addName(me);
console.log(me.name);//cyy

以上證實：因爲引用類型做爲參數時，實質上也是值傳遞。所以當形參被指向新的地址時，並無對實參進行操做，由於兩者並非指向同一個地址

typeof 檢測數據類型，返回值都是字符串類型

數組和對象都是返回object

instanceof Array 判斷是不是數組的實例

instanceof Object 判斷是夠是object的實例（數組也是Object的實例，全部東西都是object的實例）

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

不用第三個參數，對換兩個引用類型的變量值

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

null是Null類型，屬於基本類型

console.log(typeof null);//object
console.log(null instanceof Object);//false

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。