入门与进阶第二三章

进入JavaScript

值与类型

-可用的内建类型

-string、number、boolean

-null和undefined、object、symbol(ES6新增类型)

-typeof a-->询问a中的值的类型-->typeof null-->”object”

 

对象

-object-->一种复合值，可以设定属性

-点号标记法(obj.a)-->易读，首选

-方括号标记法(obj[“a”])-->属性(键)名称含有特殊字符-->变量或string字面量

var obj= {

        a:"helloworld",

        b:42

};

var b="a";

obj[b];                 // "helloworld"

obj["b"];               // 42

-数组和函数-->object类型的特化版本

 

数组

-一个数组-->一个objectà使用数字索引的位置

var arr = [

        "hello world",

        42,

        true

]; 

arr[0];                  // "hello world"

arr[1];                  // 42

arr[2];                  // true

arr.length;              // 3

typeof arr;              // "object"

 

函数

-object的子类型-->”function”

function foo() {

        return42;

} 

foo.bar ="hello world";

typeof foo;                       // "function"

typeof foo();            // "number"

typeof foo.bar;          // "string"

 

内建内型的方法

-基本类型值-->”封箱”为对应的对象包装器(操作隐藏在幕后)

 

值的比较

-强制转换-->明确的/隐含的

-falsy-->””/0，-0，NaN/null，undefined/false

-truthy-->其他(数组，对象，函数…)

-等价性

       -==和===-->==允许强制转换条件下检查值的等价性(===不允许，严格等价)

       -比较值中有true/false,0/””/[]-->用===

       -非基本类型值(object…)-->简单的检查引用(array会默认用逗号强转为string)

var a = [1,2,3];

var b = [1,2,3];

var c ="1,2,3"; 

a == c;          // true

b == c;          // true

a == b;          // false

-不等价性

-关系比较-->NaN不大于不小于不等于一切数字值

 

变量

-变量名-->合法的标识符(保留字)

 

函数作用域

-var变量-->属于当前的函数作用域(顶层-->全局作用域)

-提升-->var的声明作用于整个作用域，作用域任何位置可以访问(函数常用)

-嵌套的作用域

       -let-->声明属于个别块的变量

 

条件

-if、switch、条件操作符(三元操作符)

 

Strict模式

-收紧了一些特定行为的规则-->更安全合理、更强的可优化性

-“use strict”;-->不允许省略var进行的隐含自动全局变量声明

 

函数作为值

-匿名函数表达式/命名函数表达式

 

-立即被调用的函数表达式(IIFE)

(functionIIFE(){

        console.log( "Hello!" );

})();

// "Hello!"

-经常用于定于变量-->不会影响IIFE外面的代码

 

闭包

-即使函数已经完成了运行，它依然可以“记住”并持续访问函数的作用域

functionmakeAdder(x) {

        // 参数 `x` 是一个内部变量 

        // 内部函数 `add()` 使用 `x`，所以它对 `x` 拥有一个“闭包”

        functionadd(y) {

                 return y + x;

        };

        return add;

}

 

// `plusOne` 得到一个指向内部函数 `add(..)` 的引用，

// `add()` 函数拥有对外部 `makeAdder(..)` 的参数 `x`

// 的闭包

var plusOne =makeAdder( 1 );

// `plusTen` 得到一个指向内部函数 `add(..)` 的引用，

// `add()` 函数拥有对外部 `makeAdder(..)` 的参数 `x`

// 的闭包

var plusTen =makeAdder( 10 );

plusOne( 3 );            // 4  <-- 1 + 3

plusOne( 41 );           // 42 <-- 1 + 41

plusTen( 13 );           // 23 <-- 10 + 13

-模块-->定义对外界不可见的私有实现细节(变量，函数)和对外可访问的公用API

 

this标识符

-this不是指函数本身

functionfoo() {

        console.log( this.bar );

} 

var bar ="global"; 

var obj1 = {

        bar:"obj1",

        foo: foo

}; 

var obj2 = {

        bar:"obj2"

};

// --------

foo();                            // "global"

obj1.foo();                       // "obj1"

foo.call( obj2 );        // "obj2"

newfoo();                        // undefined

 

原形

var foo = {

        a:42

};

// 创建 `bar` 并将它链接到 `foo`

var bar =Object.create( foo );

bar.b ="hello world"; 

bar.b;           // "hello world"

bar.a;           // 42 <-- 委托到 `foo`

 

旧的和新的

-填补Polyfilling 唯一与自己不相等的值-->NaN

-转译transpiling 唯一不能作为参数默认值的明确传递的值-->undefined

 

非JavaScript

-很大一部分代码不是直接javaScript控制的

-DOM API

       -document、getElementById()、alert()、console.log()、、、

第三章：进入YDKJS

 

作用域和闭包

-JS是“解释型语言”因此是不被编译的-->错误

-JS引擎在你的代码执行的前一刻(有时是在执行期间)编译它

 

this和对象原型

-this指代它所出现的函数-->错误

-this根据函数如何被执行而动态绑定

-对象原型属性-->”行为委托”

 

类型和文法

-类型强制转换-->应当在代码中使用的

 

异步与性能

-回调-->开启异步的主要方法(两个不足之处)

       -控制反转(IoC)信任丢失

       -缺乏线性的可推理性

-ES6引入两种新的机制(模式)

       -promise

       -generator

 

ES和未来

-解构，参数默认值，symbol，简洁方法，计算属性，箭头函数，块儿作用域，promise，generator，iterator，模块，代理，weakmap、、、

-学习JavaScript不是一个最终目标，而是一个过程。