JavaScript学习day02

数组

特点:可放入任意数据类型，用逗号隔开

// 1. 利用new创建数组    
var arr1 = new Array(2);//创建一个空数组，括号里的数字是数组长度    
// 2. 利用数组字面量创建数组    
var arr2 = ['a','b',1,true,2.99];//可放入任意数据类型
var arr3 = new Array(2,3);//等价于[2,3]
//检测是否为数组的两种方法
console.log(arr1 instanceof Array);
console.log(Array.isArray(arr2));

追加元素

var arr = ['a','b',1,true,2.99];//可放入任意数据类型    
// 1. 新增数组元素    
arr.length = 7;//把数组长度修改为7    
console.log(arr[5]);//undefined
// 2.新增数组元素，修改索引号，追加数组元素    
var arr1 = [1,2,3];    
arr1[3] = 4;    
arr1[4] = 5;    
console.log(arr1);//[1,2,3,4,5]
// push方法
arr1.push('a','b')；
console.log(arr1.push(2));//返回的是新数组的长度
//unshift 在数组开头添加元素，返回的是新数组的长度
arr1.unshift('red');
//pop方法，删除数组最后一个元素
arr1.pop();
console.log(arr1.pop());//返回被删除的元素
//shift方法 删除数组的第一个元素

函数

方式一：function 函数名（参数）{函数体}

var arr = [1,2,2,3,5,5,7,8,9]    
function getSum(arr){        
	var sum = 0;        
	for(var i=0; i<arr.length; i++){            
		sum += arr[i];        
	}        
	return sum;            
}    
console.log(getSum(arr));

方式二：函数表达式（匿名函数）
var fun = function(){函数体}
fun是变量名，不是函数名
函数表达式也可以传递参数（同方式一）
注意：

1. 如果实参个数多于形参的个数，会取到形参的个数，剩下的不管了
2. 实参个数少于形参个数，多余的形参定义为undefined，结果为NaN
3. return只能返回一个值，如果返回多个值，返回的结果是最后一个值，多个值用数组返回
4. 没有return语句返回undefined

arguments

当不确定有多少个参数传递的时候，可以用arguments来获取。在JavaScript中，arguments实际上是当前函数的一个内置对象。所有函数都内置了一个arguments对象，arguments对象中存储了传递的所有实参。
arguments展示形式是一个伪数组，并不是真正意义上的数组，可以遍历，伪数组具有以下特点：

1. 具有数组的length属性
2. 按照索引的方式进行存储
3. 他没有真正数组的一些方法 pop()、push()等

function fn(){        
	console.log(arguments);        // 可按照数组的方式遍历        
	for(var i=0; i<arguments.length; i++){            
		console.log(arguments[i]);        
	}   
 }   
 fn(1,2,3);//Arguments(3) [1, 2, 3, callee: ƒ, Symbol(Symbol.iterator): ƒ]

作用域

作用域的目的是提高程序可靠性和减少命名冲突
分为两种：

1. 全局作用域：整个script标签 或者是一个单独的js文件
2. 局部作用域（函数作用域）：在函数内部就是局部作用域

全局变量和局部变量

var num = 10;//全局变量    
function fun(){        
	num1 = 20;//全局变量,在函数内部没有声明直接赋值的变量也是全局变量 
	var num2 = 30;//局部变量   
	}    
fun();    
console.log(num);//10    
console.log(num1);//20

作用域链

内部函数访问外部函数的变量，采取的是链式查找的方式来决定取哪个值，这种结构成为作用域链（就近原则）

var num = 10;//全局变量    
function fun(){        
	var num = 20;        
	function fn(){            
		console.log(num);           
	}        
	fn();    
}    
fun();//20

预解析

js引擎运行js分两步：预解析 、代码执行
预解析先：ja引擎会把js里面所有的var还有function提升到当前作用域的最前面
预解析：分为变量解析（变量提升）和函数预解析（函数提升）
变量提升：就是把所有的变量声明提升到当前的作用域最前面 不提升赋值操作
函数提升：就是把所有的函数声明提升到当前作用域的最前面，不调用函数

    console.log(num);//undefined 变量提升    
    fun();//报错    
    var fun = function() {//这里fun是变量        
    	console.log(11);    
    }    
    fn();//函数提升    
    function fn() {        
    	console.log(10);    
    }

对象——复杂数据类型object

创建对象的三种方式

利用字面量创建对象

用{}，里面包含这个具体对象的属性和方法

    var obj = {        
	uname : 'echo',//在对象里面不需要声明        
	age : 18,        
	sex : '女',        
	sayHi : function(){            
		console.log('hi~');            
	}       
    }     
    // 使用对象    
    console.log(obj.uname); //对象名.属性名    
    console.log(obj['age']);//对象名[属性名]    
    obj.sayHi();

注意：

1. 属性和方法采用键值对的形式 属性名：属性值
2. 多个属性或方法用逗号隔开
3. 方法冒号后面跟的是一个匿名函数

利用new Object创建对象

    var obj = new Object();//创建一个空对象    
    obj.uname = 'echo';    
    obj.age = 18;    
    obj.sex = '女';    
    obj.sayHi = function(){        
    	console.log('hi~');    
    }    
    //调用没什么变化

利用构造函数创建对象

前两种创建方式一次只能创建一个对象
构造函数，就是把我们对象里相同的属性和方法抽离出来放到一个函数里面去

// 构造函数是泛指的某一大类，类似java的类
    function Tfboys(uname,age,sex,song){        
	this.name = uname;        
	this.age = age;        
	this.sex = sex;        
	this.sing = function(song){            
		console.log(song);          
		}    
	}   
// 创建对象，也叫对象的实例化	
    var yyqx = new Tfboys('易烊千玺',18,'男');     
    var wjk = new Tfboys('王俊凯',19,'男');    
    console.log(typeof yyqx);//object    
    console.log(yyqx.name);//易烊千玺    
    yyqx.sing('nothing to lose');

new执行时会做四件事：

1. 在内存中创建一个新的空对象
2. 让this指向这个新对象
3. 执行构造函数里面的代码，给这个新对象添加属性和方法
4. 返回这个对象

遍历对象for…in

    var obj = {        
    	uname : 'echo',        
    	age : 18,        
    	sex : '女',        
    	sayHi : function(){            
    		console.log('hi~');            
    	    }     
    	}     
    	// 遍历对象for...in    
    	for (var k in obj){        
    		console.log(k);//得到属性名  uname,age,sex,sayHi        
    		console.log(obj[k]);//得到属性值    
    	}

内置对象

JavaScript中的对象分为三种：自定义对象、内置对象、浏览器对象
前两种对象是JS基础内容，属于ECMAScript；第三个浏览器对象是JS独有的
内置对象就是指JS语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是最基本而必要的功能（属性和方法）
JavaScript提供了多个内置对象：Math、Data、Array、String等
查阅MDN文档了解内置对象属性

基本包装类型

var str = 'andy';    
console.log(str.length);//简单数据类型包装成了复杂数据类型，因此具有length属性(系统帮你自动提示为对象)

为了方便操作基本数据类型，JavaScript还提供了三个特殊的引用类型：String、Number、Boolean

简单数据类型和复杂数据类型

简单数据类型直接存放在栈里
复杂数据类型存放在堆里，在栈中存放指向堆的指针