Javascript

发表于 | 分类于

堆栈

  • 栈: 存储js的基本数据类型 undefined null string number boolean
  • 堆: 存储js的引用数据类型 function object array 引用类型的数据的地址指针是存储在栈中的，要访问引用类型的值的时候，需要先从栈中获取对象的地址指针，然后通过地址指针找到堆中存储的数据
  • 栈 线性结构 后进后出 堆 方便存储和开辟内存空间

typeof()

1
typeof(typeof(123))  => string   //任何typeof typeOf 都是string

类型转换

  • 显示类型转换
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
Number('123')    //number
Number('true')   //NaN
Number(true)     //1
Number(false)    //0
Number(null)     //0
Number(undefined)//NaN
Number('3.14')   //number

parseInt('123') //number
parseInt(true)  //NaN
parseInt(false) //NaN
parseInt(null)  //NaN
parseInt(undefined) //NaN
parseInt(NaN)   //NaN
parseInt('3.99') //3
parseInt('abc123')//NaN
parseInt('123abc')//123

null | undefined  没有toString()方法

Boolean
undefined | null | NaN | "" | 0  false  //其他都是true

var a =1 === '1'    //不进行隐式转换
//NaN不等于任何数值

isNaN('123')  //false
isNaN('a')    //true
isNaN(null)   //false
isNaN(undefined) //true
  • 隐式类型转换

function

  • 高内聚，低耦合 -> 模块的单一责任制
  • 函数声明
1
2
3
function test(){
	
}
  • 函数名的命名规则
    • 不能数字开头
    • 字母 _$
    • 包含数字
    • 小驼峰命名法 myMethods()
  • 匿名函数表达式 函数字面量
1
2
3
4
5
6
var test = function test1(){
	console.log(1)
	test1()  //test1函数内部可调用
}

//外部调用test()

  • 形参和实参数量可不等

  • js引擎默认隐式添加return

    • 终止函数执行

递归

  • 函数自己调用自己 | 性能问题
    • 规律
    • 出口

预编译

  • 1.检查通篇的语法错误

  • 1.5预编译的过程

  • 2.解释一行，执行一行

  • 函数声明整体提升，变量只有声明提升，赋值是不提升

  • 暗示全局变量 imply global variable

1
2
var a = 1
console.log(window.a) // a = window/a
  • AO activitive object 活跃对象 函数上下文
1
2
3
4
5
6
AO = {
	//寻找函数里的形参和变量声明
    //把实参赋值给形参
    //寻找函数体的声明 赋值函数体
    //执行函数体
}
  • GO global object 全局上下文
1
2
3
4
5
6
7
GO{
	//找变量
	//函数声明
	//执行
}
	//函数内部没有var提升到全局中
	//预编译只看是否有变量声明和函数声明

函数

  • 函数也是一种对象类型 引用类型 引用值

对象

  • 有些属性是我们无法访问的
  • JS引擎内部固有的隐式属性

[[scope]]

  • 函数创建时，生成的一个JS内部的隐式属性
  • 函数存储作用域链的容器，作用域链
    • AO/GO
    • AO 函数的执行器上下文 当函数被执行时前一刻
    • GO 全局的执行器上下文
    • 函数执行完成以后，AO是要销毁的
    • AO是一个即时存储容器

闭包

  • return 一个值就是引用

  • 当内部函数被返回到外部并保存时,一定会产生闭包,闭包会产生原来的作用域链不释放，过度的闭包可能会导致内存泄露，或加载过慢

  • 闭包在ECMA262上的定义：当一个函数被系统创建时，闭包就会被一同创建出来

  • 一个函数统一与外界环境(作用域)捆版在一起的，这种现象叫做闭包

  • 更高的封装性和集成性

1
2
3
4
5
6
7
8
//global scope -> 闭包
function test(){  //闭包函数
	//fn test1 + test scope -> 形成闭包
    
    function test1 (){  //闭包函数
        // closure -> close 关闭
    }
}

立即执行函数

  • IIFE - immediately-invoked function expression

  • 自动执行，执行完成以后立即释放

1
(function(){}());    //W3C建议(function(){})();//表达式才能被执行符号执行//函数名自动被忽略
  • 函数声明变成表达式的方法 + - ！ || &&
1
（1，2）  //返回的是2  逗号运算符 返回后面那一个

Object

1
2
delete obj.sth
delete obj.fn
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//对象字面量
var obj = {
	name:'cny'
}

//构造函数
//系统自带的构造函数
var obj = new Object()   //与对象字面量相等
obj.name = 'cny'

//自定义构造函数
//大驼峰  与普通函数区分
function Fn(){
    this.name = 'cny'
    
    //return this    系统自动隐式return this 
    //return 原始值  number | boolean | string | undefined | null  this将不会改变
    //return 引用值  function | {} | []  return什么返回什么
}
var c1 = new Fn()

//new之前 构造函数的this指向window  | 构造函数本身
//new实例化后 this指向实例化出来的实例对象包装类

包装类

  • 原始值没有自己的方法和属性

  • 原始值通过构造函数实例化之后可以添加属性和方法

  • undefined 和 null 不可以设置任何的属性和方法

1
2
3
4
5
6
7
//JS包装类
var a = 123;
a.len = 3
//new Number(123).len = 3; delete

var str = 'abc'
console.log(str.length)  // console.log(new String(str).length)  包装类

ASCII码 表1 0 - 127 表2 128 - 255 1个字节 byte

UNICODE码 涵盖ASCII码 2个字节 charCodeAt()

Prototype

  • 构造函数实例化出来的对象永远指向构造函数的原型对象

  • prototype.constructor -> 构造函数本身

1
2
3
4
5
function Car(){
	var this = {
		_proto_:Car.prototype    //_proto_  键值对的键名
	}
}
  • 引号最好使用单引号，双引号有可能造成后端转译冲突
1
2
3
4
5
6
//防止变量污染  立即执行函数  插件封装
;(function(){
	function Test(){}
	window.Test = Test
})();
var test = new Test();

高阶函数

  • 闭包 + 回调 -> 高阶函数
  • 回调
    • callback -> 回应 -> 通讯的回应
    • call -> 调用 行为
    • trigger -> 出发 -> 事件的发生
    • CALL -> Function | Trigger -> Event
    • event -> 通过一个程序或者是交互被处罚 -> 执行相应的处理程序