JavaScript-进阶篇(一)之变量

变量

变量就是保存数据的容器

命名

变量名:
1.$ _ 字母 数字,数字不能开头
2.区分大小写
3.关键字: if for...
保留字: class...

声明

var score;
score = 4;

var score = undefined;
score = 4; 

var score = 4;

var aScore = 8;
var bScore = 1;

var aScore = 8,
    bScore = 5;

数据类型

基本类型 : 4 'str' true/false undefined null
引用类型 : [] {}

区别:基本类型值不会改变,引用类型会改变

var num = 6;
num = 5 //覆盖

var person = 'person';
person.name = 'xiaoming';
console.log(person.name);   //undefined

堆栈

image.png
基本类型保存在栈中,栈的空间的是有序且大小固定的,而堆中是大小不固定且无序的.在栈中保存的引用类型是一个引用地址

相等比较

var a = 4;
var b = 4;
console.log(a === b);   //true

var xm = {
    age:18,
    scroe:4;
};
var xh = {
    age:18,
    score:4
}
console.log(xm === xh);     //false

由于对象之间的比较是判断的地址是否相等,每个地址开辟了不同的堆内存空间,因此只有当两个变量是同一个对象的引用时,才相等

var xm = {
    age:18,
    scroe:4;
};
var xh = xm;
console.log(xm === xh);     //true 
function equal(a,b){
    for(var p in a){
        if (a[p] !== b[p]) return false;
    }
    return true;
}
console.log(equal(xm,xh));      //true

复制变量的值

var xm = 4;
var xh = xm;
xm++;
console.log(xm);    //5
console.log(xh);    //4

参数传递

//基本类型的参数传递
function addTen(){
    return num + 10;
}
var score = 10;
console.log(addTen(score));     //num = score;

//引用类型的参数传递
function setName(obj){
    return obj.name = 'xm';
}
var person = {}
setName(person);
console.log(person.name);    //obj = person 传递了对象地址的值

function setName(obj){
    obj.name = 'xm';
    obj = {};   //此时的Obj不再是person
    obj.name = 'xh';
}
var person = {};
setName(person);
console.log(person.name);   //xm

检测类型

//typeof
console.log(typeof 3);      //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      只能和引用类型使用
console.log([] instanceof Array);   //true
console.log([] instanceof Object);  //true
console.log({} instanceof Object);  //true
console.log({} instanceof Array);   //false

全局作用域和局部作用域

• 变量的生命周期
• 访问到变量

var name = 'greentea';    //全局作用域的生命周期在脚本执行完毕才会销毁
function fn(argument){
    var sex = 'male';    //局部作用域在函数执行结束即销毁
}
fn();

没有块级作用域

变量对象和作用域链

var name = 'xm';
function fn(){
    var sex = 'male';
    var name = 'xh'
    function fn2(){
        var name = 'xhei'
        var age = 18;
    }
}
console.log(window.name === name);      //true

全局作用域的变量对象是window,而局部作用域的变量对象是显示不出来的.
查找变量先从当前作用域中查找,如果没有向上一层查找

预解析

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

JS的解析过程:
1.预解析
由全局向局部预解析.首先,将所有的变量var赋值undefined.然后将函数声明
如果变量名和函数名相同,则只存在函数名
2.逐行解读代码

解析机制详解

问题一:

//1
console.log(b);      //undefined
var b = 1;

//2
console.log(a);      //报错
a = 1;

预解析先去找var,因a没有var,导致报错

console.log(a);
var a = 1;
console.log(a);
function a(){
    console.log(2);
}
console.log(a);
var a = 3;
console.log(a);
function a(){
    console.log(4);
}
console.log(a);
a();

//预解析先会将var a = undefined,但是又有a的function,因此,a变量被function替代,只剩下function a.
//然后a被赋值为1,3...最后执行a(),因为a被赋值后是变量,所以会报错

var a = 1;
function fn(){
    console.log(a);     //undefined
    var a = 2;
}
fn();
console.log(a);
//首先预解析var定义undefined,在fn()中的预解析中a定义为undefined.因此a为undefined

var a = 1;
function fn(){
    console.log(a);     //1
    a = 2;
}
fn();
console.log(a);     //2
//里面没有var,就在外面去找,然后a = 2是全局的,因此为2

var a = 1;
function fn(a){
    console.log(a);     //undefined
    a = 2;
}
fn();
console.log(a);     //1
//参数相当于var

var a = 1;
function fn(a){
    console.log(a);     //1
    a = 2;
}
fn();
console.log(a);     //1
//传进来以后是全局变量了

垃圾回收机制

释放无用的数据,回收内存

自动:JS
手动:Objective-C
原理:找出那些没用的数据,打上标记,释放其内存,周期性执行,标识无用数据的策略
标记清除:离开其作用域以后,会被清除
引用计数(不常用)