JavaScript总结（1）

1) 执行模型

1.1)    单线程编程模式，不可能在进一步创建一个线程。

1.2)    基于Event，Event循环，Event队列

//event循环While(true){    e = getEvent();   //阻塞调用    invokeHandler(e); //执行到结束}

2) 基本类型 Number, String, Boolean

2.1)Number

vara = new Number(2);varb = 5;a+b//7

2.2)String

var a = new String(‘Hello’);var b = ‘World’;a + ‘ ’+ b     // ‘Hello World’

2.3)Boolean

var a = new Boolean(false);var b = true;a && b   //true  ,这里注意和Java的区别

3) 原始类型和对象类型

Var a =2;a.foo= ‘bar’;a.foo //undefined  这里是undefine var a = new Number(2);a.foo = ‘bar’;a.foo    //  ‘bar’

4) Number陷阱

0.1 + 0.2  // 0.30000000000000000004有趣言论：Everything you neverwanted to know about JavaScript numbers(and you didn’t know you could ask)

5) String 陷阱

Javascript：==   没有类似Java中的equals()方法Var a = ‘Hello JavaScript’;a.substring(6,10)     //索引6位到10位， ’Java’a.substr(6,10)        //索引6位起，连续10位，JavaScript

6) Boolean陷阱

var a = new Boolean(false);if(a){    // 这里代码执行！！！} var b = false;if(b){    //这里代码不执行}

7) Boolean Fallen

Var a = new Boolean(‘HelloJavaScript’);// a是一个Boolean对象true。Var b = Boolean(‘HelloJavaScript’);// b是一个原始对象true，这种方法对内存要求更低 a == b    //truea === b  //false

8) 函数

8.1一等公民

8.2行为和逻辑

8.3函数也是一个对象

Var go = function(){ alert(‘HelloJavaScript’); }go();go.foo = ‘bar’;go.foo     // ‘bar’

8.4参数

//参数a不是必选，可以不传而触发函数，这是和Java的区别Var go = function(a){   alert(‘Hello’+a);  };go(‘JavaScript’);go();

8.5返回值

Var go = function(){ return ‘JavaScript’;};Var a = go();a  // ‘JavaScript’ var go = function(){console.log(‘JavaScript’); };var a = go();a   // undefined

9) 变量

9.1 命名规则

1) 没有空白键

2) 不以数字开头

3) 没有破折号

4) 没有JS关键字

5) 允许UTF-8字符来命名

Var x;

X === undefined;  //true

9.2 初始类型

Var a =3.14; //声明一个初始化变量Var b = a;   //拷贝变量值a =4;        //修改初始值alert(b);    //显示3.14，拷贝值不变

9.3 对象类型

Var a = [1,2,3];  //初始化一个变量数组Var b = a;         //拷贝一个引用，不是变量本身。a[0] = 99;         //修改数组初始值alert(b);          //显示修改后的引用值// => [99,2,3]

9.4 类型强制转换

两个等号的类型强制转换

null = undefined;        //truefalse == 0;               //true‘ ’ == 0;               //true‘5’ == 0;               //true

==预览

1 == 1       //return true“1” == 1   // return true (“1”转换成了1)1 == true    //return true0 == false   // return true“” == 0     // return true (“”转换成了0)“ ”== 0     // return true (“ ”转换成了0)0 == 1        //return false1 == false    // return false0 == true     // return false

!=预览

0 ！= false  // return false‘’ != 0    // return false (‘’转换成了0)‘’！= 0    // return false(‘ ’转换成了0)0！= 1      // return true1 != false    // return true0 != true     // return true

===预览

1 === 1       //return true‘1’ === 1   // return false (‘1’不会转换)1 === true    // return false0 === false   // return false‘’ === 0     // return false （‘’不会转换）‘’=== 0     // returnfalse （‘ ’不会转换）0 === 1        // return false1 === false    // return false0 === true     // return false

==对象比较

Var x, y;     // 声明x和y    x = {}   // 产生一个对象并赋给x    y = x;   // y指向x    x == y;  // return true(内存中引用同一个对象)    x == {}; // return false (不是同一个对象)

！=对象比较

Var x, y;             // 声明x和y    x = {};           // 产生一个对象并赋给xy= x;            // y指向xx!= y;           // return false (引用同一个对象)x!= {}           // return true (不是同一个对象)

===对象比较

Var x, y;             // 声明x和y    x = {};           // 产生一个对象，并赋给xy= x;            // y指向xx=== y;          // return true (引用同一个对象)    x === {};         // return false (不同对象)比较对象而言，==和===没有区别。

原始封装对象比较

new Number(3) == new Number(3)      // false 不是同一个对象new Number(3) === new Number(3)     // false 不是同一个对象new String(‘A’) == newString(‘A’)// false 不是同一个对象new String(‘A’) === newString(‘A’)// false 不是同一个对象new Boolean(true) == new Boolean(true)//false不是同一个对象new Boolean(true) === newBoolean(true) // false不是同一个对象比较对象而言，==和===没有区别。

Falsy值

False0 (zero)‘’ (empty string)‘ ‘ (String包含任意个空白键)nullundefinedNaN

考虑到性能，===比较==无疑有更多优势

 

If语句中的转换

if(‘’)    // falseif(‘5’)   // trueif( 0 )     // falseif( -1 )    // trueif( null )  // falseif( undefined) // false

10) 作用域

1、作用域是基于函数的

Var something = 1;If(true){    Var something = 2;    Console.log(‘Inside: ’+ something);}Console.log(‘Outside: ’+something); // => 2// => 2 Var variable = ‘parent scope’;Function fn(){    Var variable = ‘local scope’;Console.log(variable);}Console.log(variable);Fn(); // => parent scope// => local scope  (functionfirst(){    Var a = ‘Robin’;    (function second(){        Var b = ’Phil’;        (function third(){    Var c = ‘Sascha’;    console.log(a,b,c);})();})();}();

函数域

(function(){    // Here is a new scope!    // From outside nobody can access this scope!})();

传递参数

(function($){    // Here is a new scope!    // From outside nobody can access this scope!})(jQuery);

存放初始值undefined

(function($, undefined){    // Here is a new scope!    // From outside nobody can access this scope!    // undefined has its original meaning here!})(jQuery);

Overwrite undefined, fix the bugs??? Won’t do it again?

 

返回一个值

Var myService = (function(){    // Here is a new scope!    // From outside nobody can access this scope!    Var a = 42;    Var b = ‘TEST’;     return{       getA: function(){ return a; },       getB: function(){ return b; }};})();