堆内存 栈内存问题
栈内存 是用来存储 基本数据类型(提供代码运行环境) 内存小 速度快
堆内存 是用来存储 引用数据类型 内存大 速度慢
var a = 12;
var obj = {q:1,w:2};
var obj2 = obj;//(xxxfff000)
//先去开辟一个堆内存,把属性名和属性值一对一对存储到堆内存中;
// 把这个堆内存的地址(xxxfff000) 赋给 obj(xxxfff000);
JavaScript 函数
函数是由事件驱动的或者当它被调用时执行的可重复使用的代码块。
我们要用函数的原因
1、 节省代码
2、 高内聚(把东西缩到一块,这一块就是为了实现某个功能,跟其他代码没有任何联系) 低耦合(跟其他代码没关联)
function 函数名(){
函数体
}
var 函数名 = function 函数名-可写可不写(){
函数体
}
* 第一种声明方式, 我们在声明的代码的之前调用这个函数
* 第二种声明方式, 我们只能在声明的代码之后调用
*
* 函数声明之后 可以无限次调用
*
* return //返回的意思
*
* */
clearRoom();//函数的调用 --> 函数名()
function clearRoom() {
console.log('收拾桌子');
console.log('收拾卧室');
console.log('出门');
}
// clearRoom();
// clearPer();
var clearPer = function (){
console.log('洗脸');
console.log('刷牙');
console.log('穿鞋');
return '出门';// return 什么 那函数执行完 返给外界的就是啥
};
var a = clearPer();//把函数执行的结果赋值给 a
console.log(a);
// clearPer();
function sum() {
var a = 10;
var b = 20;
var total = a + b;
return total;
}
total
var t = sum();
console.log(t);
函数的传参
函数的传参 (就是一个接收的的过程)
function sum(a,b){
//a和b 叫形参(形式上的参数)
}
function sum(a,b) {
console.log(a,b);
var total = a + b;
return total;
}
sum(1,2); // 1,2 是实参 (实际的参数)
sum(3,4); //
截至目前
函数的声明 (2种)
函数的执行 (函数名())
函数的返回值 (return) return 后边的代码不再执行 跟 for中的 break和continue 类似
函数的形参 (听指令的功能 || 管道入口)
函数的实参 (说指令 || 填入洗衣液和水)
arguments // 实参集合
this // 函数的执行主体 (谁调用的这个函数)
function sum2() {
console.log(arguments);//为了让大家看arguments 是什么
var total = 0;
for(var i = 0; i < arguments.length;i++){
// var total = arguments[i] + arguments[i+1]
total += arguments[i];
}
console.log(this);
return total;
total = 400;
return total;
}
console.log(sum2(1, 2, 3, 4));
1、当实参个数大于形参个数时,他们是按照先后顺序一一对应的
2、当实参个数小于形参个数时,没有对应上的形参会有一个(undefined)默认值
//两个数的求和
function sum(a,b) {
console.log(a,b);
var total = 0;
total = a + b;
return total;
}
// sum(1,2);//3
// console.log(sum(1, 2, 3, 4));// 3
函数中的this 指向问题:函数执行 看点前边是谁 函数中的this就是谁
var obj = {
fn: sum,
w:12
};
sum();
obj.fn();
var oDiv = document.getElementById('div1');
oDiv.onclick = function () {
console.log(this);
};
//自己就能执行
(function () {
console.log(22)
})()
函数的声明存储
//对象的存储过程
var obj = {
w:1,
e:2
};
obj = {q:1};
//1、新开辟一个堆内存
//2、把属性名和属性值,一对一对的存到堆内存中
//3、把这个对内存的地址(xxxfff000) 赋给 obj这个变量
//函数的存储过程
function sum(a,b) {
return a + b;
}
//1、新开辟一个堆内存
//2、把函数体当作字符串存到这个堆内存中
//3、把这个对内存的地址赋给 函数名 sum
sum();
var n = parseFloat('width:100px');
if(n > 100){
console.log(200)
}else if(n == 100){
console.log(100)
}else if(n == NaN){
console.log('NaN')
}else {
console.log('good')
}
匿名函数
就是没有名字,没有命名的函数
第一种匿名函数
//第一种匿名函数
var sum2 = function (a,b,c) {
console.log('var')
}
sum2();
第二种匿名函数
(function () {
console.log('这是一个自执行函数1')
})();
!function () {
console.log('这是一个自执行函数2')
}();
~function () {
console.log('这是一个自执行函数3')
}();
函数总结
//1、 函数的定义 (2种)
// function 函数名(){函数体}
// var fn = function(){}
//2、return 可有可无 ;
// 跳出函数体
// 确定返回值
// 当不写return时,函数执行返回的 *结果* 是undefined
// 当写了 return 但是后边没有任何内容;这时的 执行返回的结果 undefined
// return a+b; 它是把表达式运行的结果返回出去
// return 的位置 不固定, 根据业务需求来确定 return的位置;
//3、形参 和 实参
// function sum(a,b,c){} // a b c 在函数定义阶段确定的参数是 形参
// sum(1,2,3) // 在函数调用的阶段,传进去的参数叫做实参
// sum(1) // b c 多余的形参给的默认值是 undefined
// sum(1,2,3,4) // 多余的实参 没有对应的实参接收,形参是按照先后顺序来接受实参的
//4、arguments (实参集合)
//它是一个函数内部的属性,跟咱们设不设置形参 和 传不传 实参 是没有关系的;他一直都存在
function sum() {
console.log(arguments)
}
sum(1,2,3)
//5、this :函数的执行主体 ; 谁调用的函数;简单规律就是看点 点前边是谁 函数中的this 就是谁