javascript 跟 强类型语言不同的特性

1.变量的作用域
var b = 5
function fn()
if(true)
{
var a = 10
}
g = 11
}
上面的代码中,b 和 g 是全局变量,都在当前window对象下,作用域也就是当前窗口.变量a 作用域是函数fn ,别看a 定义在if块里面,在函数块的其它地方也可以访问到a的值,ES6以后为了严谨,出现了let 符号申明变量,表示只能在当前块里面访问.

1. 下面定义的对象o,中的this的作用域不是window,而是当前这个对象
   var prop = 66
   var o = {
   prop:100,
   fn:function()
   {
   alert(this.prop)
   }
   }

3.通过闭包可以访问函数内部的资源(变量等),通常情况外部作用域是不能访问内部作用域资源的.
function test(i)
{
function add()
{
i++
}
return add;
}

var func = test(0)
func()//1
func()//2

4.一个没有参数的函数,在调用的时候可以动态的给函数加上参数,并用this来得到参数
function test()
{
alert(this.a);
//alert(a)
}
test.call({a:1000})

5.函数定义之后立即执行,一般用于只调用一次的函数(匿名函数)
(function (name){
alert(‘hello,’ + name)
})(‘world’)
用小括号把函数定义包含在里面,后面的()表示调用此函数

6.数字类型可以转为boolean 类型(C语言貌似也有此特性,不过在Java语言中直接有代码检查异常
function test()
{
if(!0)
{
alert(1)
}

if(1)
{
    alert(2)
}

if(-1)
{
    alert(-1)
}

if(!0.0)
{
    alert(0.0)
}

}
test()
当数字值是0或0.0的时候数字会转换为false,其它值为true.

7.上述第6说的是在一个函数内部,如果外部也定义了和内部一样变量名的变量.函数执行的时候会在本函数里面看看有没有定义变量,如果有,则函数任何位置都可以使用此变量,只是在未初始化时值是undifined,undifined 转换为boolean 永远是false.

a = 1000
function test()
{
if(!a)
{
var a = 2
}

alert(a)

}
if 里面的a的值此时是undifined,取反后是true
如果函数里面没有var a ,则开始的a会被解析为全局变量a = 1000.

8.javascript 可以在js 文件上下文直接写语句执行,比如循环,条件分支,赋值等(在java直接编译出错).其执行就如同定义后立即执行的函数.

9.循环改变全局变量需要注意 ++a 和 a++的区别.
在java 中无论全局还是局部变量 a++ 都会把a++值累计到a变量上.但是javascript不同,它每次都会重新到全局去取改变之前的值,这样循环累加永远不能改变a++的值.局部变量或局部代码运算就没有此问题.

var g = 1,
i = 0;

function test(){
for(;i < 5;i++)
{
g = g++
alert(g)//一直是1
}
}

test()
如果把g++ 改为++g就可以正常改变g的值.

10.第二点我们已经提到在一个对象定义范围内,this的作用域仅仅是对象内部.但如果,单独把对象中的函数被一个新的引用指向,并调用this的时候是访问不到this的.

var obj = {
count: 1,
func: function(count) {
alert(this.count);
alert(count);
}
};

(function test() {
var count = 10;
obj.func(count);

var gunc = obj.func;
gunc(count);

})();
上面的代码打印顺序是1,10 undifined, 10.全局变量都能直接范围.而gunc函数由于脱离了obj 调用 所以访问不到this.count.所以值是undifined.

11.javascript 大部分语法都不像强类型语言那样写错了就报错.它是在执行时候才会报错,javascript不仅仅是弱类型,还是解释类型的语言.不过一个函数执行中遇到不能解释的代码会直接跳过本函数的执行.
var a = 1;
function fn() {
a = 2;
alert(’ ss’+a)
return;
function a() {}
}
fn();
alert(a);
上面的代码可以执行,打印的是1,即便是return 之后有代码这种语法造成编译器无法解释执行.干脆整个函数都不执行了.所以结果是1.

12.下面是一道面试题目:
var foo = {n: 1};
var bar = foo;
foo.x = foo = {n: 2};

alert(bar.n);//1
alert(bar.x);//object
alert(bar.x.n);//2
alert(foo.n);//2
alert(foo.x);//undifined

估计很少有人能真正解释foo.x = undifined.这里我的解释是,一开始
foo.x = foo 等价于 foo.x = {n:2}
这个时候foo和bar还是指向{n:1}的,不过foo多了一个属性x : {n:2},那么
bar也应该有这样一个属性.
接着才执行 foo = {n:2} //这一步直接让foo的引用指向了新的对象{n:2}
bar 跟这个foo 已经没有关系了.