练习1.
<script>
function fun(num){
console.log(num);
var num = 5;
console.log(num);
}
fun(10)
//分析一波
// 1.分析全局变量GO，生成go对象
// GO={
// 全局变量声明：
// 没有略过
// 全局函数声明：
// fun：function;
// }
// 2.逐行执行
// 3.分析AO，生成AO对象
// AO={
// 1.分析参数
// num：10
// 2.分析变量声明：
// num:undefind 然后赋值为5
// 3.分析函数声明
// 没有略过
// }
// 最后输出：
// 第十行输出是10 输出的是参数 num
// 12行输出为5 输出的是变量num
</script>
2.
<script>
function fun(ger){
console.log(ger);
function ger(){
alert("hello world");
}
}
fun(5)
//分析一波
// 1.分析全局变量GO，生成go对象
// GO={
// 全局变量声明：
// 没有略过
// 全局函数声明：
// fun：function;
// }
// 2.逐行执行
// 3.分析AO，生成AO对象
// AO={
// 1.分析参数
// ger：5
// 2.分析变量声明：
// 没有略过
// 3.分析函数声明
// ger：function;
// 重复名称覆盖
// }
// 最后输出：function ger(){
// alert("hello world");
// }
</script>
3.
<script>
function fun(ger){
console.log(ger);
var ger = function(){//函数表达式
alert("hello world");
}
}
fun(5)
//分析一波
// 1.分析全局变量GO，生成go对象
// GO={
// 全局变量声明：
// 没有略过
// 全局函数声明：
// fun：function;
// }
// 2.逐行执行
// 3.分析AO，生成AO对象
// AO={
// 1.分析参数
// ger：5
// 2.分析变量声明：
// 没有略过
// 3.分析函数声明
// 没有略过
// 重复名称覆盖
// }
// 最后输出：5
</script>
4.
<script>
function a(b){
console.log(b);
function b(){
console.log(b);
}
b();
}
a(1)
//分析一波
// 1.分析全局变量GO，生成go对象
// GO={
// 全局变量声明：
// 没有略过
// 全局函数声明：
// a：function;
// }
// 2.逐行执行
// 3.分析AO，生成AO对象
// AO={
// 1.分析参数
// b：1
// 2.分析变量声明：
// 没有略过
// 3.分析函数声明
// b：function;
// 重复名称覆盖
// }
// 最后输出：第十行的时候 输出的是function b的表达式 因为函数声明
// 在十四行调用函数 function b的时候
// 第十二行的时候也是函数function b 的表达式
</script>
5.
<script>
function a(b){
console.log(b);
var b = function(){//函数表达式
console.log(b);
}
b();
}
a(1)
//分析一波
// 1.分析全局变量GO，生成go对象
// GO={
// 全局变量声明：
// 没有略过
// 全局函数声明：
// fun：function;
// }
// 2.逐行执行
// 3.分析AO，生成AO对象
// AO={
// 1.分析参数
// b：1
// 2.分析变量声明：
// 没有略过
// 3.分析函数声明
// 没有略过
// 重复名称覆盖
// }
// 最后输出： 1 function b的函数
</script>
7.
<script>
// 第一题
function test(a,b){
console.log(a);
console.log(b);
var b = 234;
console.log(b);
a = 123;
console.log(a);
function a(){};
var a ;
b = 234;
var b = function(){};
console.log(a);
console.log(b);
}
test(1);
//分析一波
// 1.分析全局变量GO，生成go对象
// GO={
// 全局变量声明：
// 没有略过
// 全局函数声明：
// test：function
// }
// 2.逐行执行
// 3.分析AO，生成AO对象
// AO={
// 1.分析参数
// a：1
// 2.分析变量声明：
// a:undefind
// b:234
// 3.分析函数声明
// 没有 忽略
// 重复名称覆盖
// }
// AO={
// a:function
// b：234
// }
// 最后输出：11行：函数a function a在17行提前声明
// 12行：undefined b声明提前 赋值在13行
// 14行：234； 输出13行赋值过后的b
// 16:123 在15行赋值a为123 在十六行输出
// 21：123 赋值过后的a
// 22：function 在二十行b定义为函数表达式
//
//
</script>
8.
<script> console.log(test); function test(test){ console.log(test); var test = 234; console.log(test); function test(){} } test(1); var test = 123; //分析一波 // 1.分析全局变量GO，生成go对象 // GO={ // 全局变量声明： // test:123; // 全局函数声明： // test：function // } // 2.逐行执行 // 3.分析AO，生成AO对象 // AO={ // 1.分析参数 // test：1 // 2.分析变量声明： // test:234 // 3.分析函数声明 // test:funtion // 重复名称覆盖 // } // AO={ // test:funtion // } // 最后输出：9行：undefined 全局变量提前声明 但是赋值在17行 错误 // 9行 输出的是 function test 先声明的是变量后声明的是函数，函数把变量覆盖了 // 11行：function test // 13 234 逐行运行后 在12行的时候test被赋值为234 </script>
9.
<script>
// 第三题
function test(){
console.log(b);
if(a){
var b = 100;
}
c = 234;
console.log(c);
}
var a;
test();
a = 10;
test();
console.log(c);
//分析一波
// 1.分析全局变量GO，生成go对象
// GO={
// 全局变量声明：
// a : 123
// 全局函数声明：
// test：function
// }
// 2.逐行执行
// 3.分析AO，生成AO对象
// AO={
// 1.分析参数
// 没有忽略
// 2.分析变量声明：
// b：100
// 3.分析函数声明
// 没有 忽略
// 重复名称覆盖
// }
// AO={
// b：100
// c =234
// }
// 最后的输出结果：
// 逐行运行： 在19行调用函数 function test 在第11行 输出 undefined 因为b在13行才声明
// 16 234
// 在21行第二次调用函数 a为非空 b =100 但是先输出b 然后赋值 如果输出是实在if下面就是100
// 16 234
// 22 234
</script>
10.
<script>
// 第四题
function bar(){
return foo;
foo = 10;
function foo(){};
var foo = 11;
}
console.log(bar());
//分析一波
// 1.分析全局变量GO，生成go对象
// GO={
// 全局变量声明：
// 没有忽略
// 全局函数声明：
// bar：function
// }
// 2.逐行执行
// 3.分析AO，生成AO对象
// AO={
// 1.分析参数
// 没有忽略
// 2.分析变量声明：
// foo :11
// 3.分析函数声明
// foo:function
// 重复名称覆盖
// }
// AO={
// foo:funtion
// }
// 最后输出结果：
// 在16行调用函数
// 11行 返回值为 function
// 在14行声明变量 foo并且赋值为11 是在函数 foo里面的
</script>
11.
<script>
// 第五题
console.log(bar());
function bar(){
foo = 10;
function foo(){}
var foo = 11;
return foo;
}
//分析一波
// 1.分析全局变量GO，生成go对象
// GO={
// 全局变量声明：
// 没有忽略
// 全局函数声明：
// bar：function
// }
// 2.逐行执行
// 3.分析AO，生成AO对象
// AO={
// 1.分析参数
// 没有忽略
// 2.分析变量声明：
// foo :11
// 3.分析函数声明
// foo:function
// 重复名称覆盖
// }
// AO={
// foo:funtion
// }
// 最后输出结果：
// 在10行调用函数
// 声明函数为 foo:function
// 12 foo被赋值为为10
// 14行 声明变量并且赋值为11
// 在14行声明变量 foo并且赋值为11 是在函数 foo里面的
// 15行 返回值为 11
</script>