JS总结

什么是JS

JS： javascript 简称为JS 它是一门编程语言

JS的基本语法

基本语法：
    1）JS是区分大小写  var a = 1;  var A = 2;
    2）忽略空白符（空格  换行  tab）
    3）语句分号可加可不加
    4）注释  单行注释  多行注释  注释是给程序员看的
    5）标识符 和 关键字  var a = 110;   var 关键字   a变量名标识符
    6）......
    // 单行注释
    /*  多行注释  */

JS三种写法

1）把js写在html文件中 学习时通常就写在script标签中(内部写法)

2）把JS写在JS文件中，然后在html文件中通过script标签引入 写项目时通常会把JS写在一个单独的文件中（外部写法）

3）把JS代码写在开始标签中，当成开始标签的属性（行内写法）

JS中的变量

    数据：一个软件打开后，界面上有很多的数据，也叫状态，这个状态可以保存在两个地方，一个是内存，一个是硬盘
    项目运行起来，只有把数据加载到内存中，才使用使用数据。
    内存中的数据，一断电，数据就没了，还有一个地方，也可以保存数据，是硬盘，硬盘上的数据断电是不会丢失的。
    内存空间地址：就是一块内存空间的地址，可以通过地址操作它对应空间中的数据，使用地址来操作非常不方便，指针。

    变量：变量就是内存中的一个空间。
        变量名：内存空间的别名  对变量名的操作就是对内存空间的操作
        变量值：存储在内存空间中的状态（数据）

    在JS中，如何定义变量：
        var a = 110;  // 定义了一个变量  变量的名是a  变量的值是110;

    在计算机中，=叫赋值运算符：
        1+1  + 加号  左结合性
        = 右结合性  从右向左
        var name = "wangcai";   把wangcai字符串值给name这个变量名所对应的内存空间

    变量的分类：
        1）全局变量
        2）局部变量
        分界点是：函数
        只要把变量写在函数里面就是局部变量，只要写在函数外面就是全局变量。

   全局变量和局部变量有什么特点：
        1）全局变量可以在函数内部都能访问到
        2）局部变量只能在函数内部访问到

JS中的数据类型

为什么需要数据类型？   
    为了更加合理使用内存空间，基本上所有的编程语言中都提出

数据类型的概念，研究针对不同的数据，分配不同的空间。
JS中的数据类型：
    基本数据的类型：数据存储在栈区
        number  数字  var a = 110;  int a = 110;
        string  字符串 ”“  ‘’  JS中不分字符和字符串 都叫字符串
        boolean  true false  布尔类型
        undefiend  没有值
        null  没有值
    引用数据类型：数据存储在堆区
        object  对象
            array  数组
            function 函数  在JS中函数也是一种数据类型

JS中的number数据类型

1）number是一个数据类型，这个数据类型对应的值有无数个。
2）在JS中number数据类型是不分整数和小数 都是number
3）可以通过typeof查看一个变量值的数据类型
4）最大值 和 最小值
5）number可以通过不同进制显示  进制  10进制   2进制  16进制  8进制
6）NaN  Not a Number 不是一个数字
7）JS中不要对小数运算  要运算先转成整数   得到的结果往往不对

在JS中，说到数据类型，主要指变量值的数据类型。

typeof是运算符 + - * / 都是运算符

Number叫类，也叫构造器，也叫函数

JS中的string数据类型

1）在JS中 使用‘’  “”把字符串包起来  不包 JS会给它当成变量
2）单引号不要嵌套单引号 双引号不要嵌套双引号  外单内双  外双内单
3）string数据类型对应的数据有无数个

SyntaxError表示语法错误 

JS中的Boolean数据类型

1）boolean数据类型对应的值就两个  true  false
2）true 和 True  不一样的  JS是区分大小写的

JS中的undefined数据类型

1）undefiend是一个数据类型，这种数据类型对应的值是undefiend
2）什么时候会出现undeined?
    答：一个变量没有赋值  它的值是undefiend  这个值的类型是undefiend

JS中的数据类型转化

 数据类型转化：
    隐式类型转化：静悄悄地，不知不觉地就进行了类型转化
    强制类型转化：写代码进行转化

在JS中，下面的值转成false，其它值都转成true:
    0  -0
    ""
    undefiend
    null


前提：在JS中，运算符两侧需要保存数据类型一致，如果不一致，JS解释器会帮你把一个数据类型转成另一个数据类型。

 隐式类型转化
 + 叫运算符  123操作数   "abc"也叫操作数
 一个运算符如果有两个操作数，这个运算符叫二元运算符，也叫二目运算符，还叫双目运算符
 +  -  =
 如果一个运算符只有一个操作数，这个运算符叫一元，单目运算符
 有：typeof ++ --

 +是双元运算符   运算符你要保证两侧操作数的数据类型要一致
 var res = 123 + "abc";  // 123隐式转化成字符串
 console.log(res);  // 123abc
 console.log(typeof res);  // string

 var isMerry = true;
 if(isMerry){  // 语句
      如果if后面的（）里面是true 执行{}里面的代码
     console.log("结婚了....")
 }else{
     console.log("没有结婚....")
 }

 var isLove = "";
 if后面的小（）里面要么放true 要么放false
 if后面小（）里面放了一非布尔类型的值，也会进行隐式类型转化
 if(isLove){
     console.log("是真爱");
 }else{
     console.log("是骗子");
 }

 1>2  没有类型转化   值
 if(1>2){}

 强制类型转化
/* console.log(parseInt(3.14)); // 把小数转成整数
console.log(parseInt("3.14abc")); // 尝试把小数或非数字转成整数
console.log(parseFloat(3))
console.log(parseFloat("3.14abc"))
console.log(Number("abc123"))  // NaN
console.log(Number("123abc"))  // NaN
console.log(Number("123"))  // 123
console.log(String(123456))  // 123456*/

代码段

一个script标签就是一个代码段。
JS代码在执行时，是一个代码段一个代码段执行。

JS代码在执行时分两个阶段

JS代码在执行时分两个阶段：
    1）预编译
    2）代码执行
    每一个阶段做的事情是不一样的。

定义变量和声明变量：
    定义变量：var a = 110;    定义 = 声明+赋值
    声明变量：var a = 110;  说的声明仅仅是说var a   后面是赋值

预编译： 提升
    把加var的变量进行提升  变量声明会提升  变量的赋值是不会提升
        提升到了代码段最前面
    把使用function声明的函数进行提升  提升的是整个函数声明
全局代码中： 提升到代码段最前面
                加var的全局变量  仅仅提升是声明
                加functon的全局函数  提升的是定义   定义 = 声明+赋值

             函数内部：
                加var的也会提升，提升到函数体的最前面
代码的执行：
    一行一行执行

初步了解执行上下文（ Execute Context）

执行上下文（ Execute  Context）:
    EC

EC的作用：给代码提供数据

代码分两类：
    全局代码  函数外面的代码叫全局代码
    函数代码  一个函数就是一个局部代码

 全局执行上下文：
    全局代码在执行时时，就会产生全局的EC。 EG(G)
 局部执行上下文：
    函数代码在执行时，就会产生局部的EC。调用一个函数就产生一个EC，调用100个函数，就产生100个EC。

ECStack  EC(G)  VO  EC(f) AO  GO
    ECStack 执行上下文栈
    EC(G) 全局执行上下文 存储全局的加var  加function的数据存储在VO中
        VO 变量对象   存储的全局的加var 或 加function
    EC(f) 函数执行上下文 存储局部的加var 或 加funciton的局部数据
        AO 活动对象  存储局部的加var 或 加function的局部数据
    GO 全局对象
        默认情况下，里面就存储了很多东西
            全局的数据，加Var的全局数据，加functon的全局数据，不加var的变量都会存储到GO中的

全局代码在执行时，会创建一些全局变量，全局函数，这个全局数据会被存储到一个叫VO的区域
当我们获取一个数据时，先看他是不是全局变量，如果是，看他有没有家var，如果加了就去VO中找，如果没有加就去GO中找，如果都找不到，就报这个数据没有定义

 EC栈：
    栈：杯子
    每产生一个EC就会放到杯子中，说白了，就是杯子中放鸡蛋。
    栈：先放进去的后出来

加var的变量和没有加var的变量的区别

1）在全局代码中，加var会提升，没有var的不会提升。
    console.log(a);
    a = 110;  // a is not defined

2）不管加没加var的全局变量，都会作为window的属性
    var a = 1;
    b = 2;
    console.log(window.a)
    console.log(window.b)

3）没有加var的变量，只能作为全局变量，只要是全局变量，肯定是window的属性
    function f() {
        a = 666;
    }
    f()
    console.log(window.a)

4）加var的局部变量，不会作为window的属性
    function f() {
    var a = 666;
    }
    f()
    console.log(a)
    访问一个对象上不存在的属性，结果就是und
    console.log(window.a) // undefined

了解函数

 函数是任何编程语言都有概念

 在JS中定义函数有两种形式
 函数定义
 函数表达式

 函数定义  f叫函数名  ()是函数特有的标识  {} 叫函数体
 定义 = 声明 + 赋值
 function f() {
     console.log("hello")
     console.log("js")
     console.log("vue")
 }
 函数调用
 f(); // 调用函数时，就会把函数体中的代码都执行了

 函数的返回值
 function f() {
     return 666;
 }
 函数的返回值是返回到了函数调用处
 var a = f(); // 函数调用
 console.log(a);
 console.log(f()); // f()得到的就是函数的返回值

 一个函数如果没有返回值，默认返回undefiend
 function f(){
 }
 console.log(f()); // undefined

 und出现的地方？
 答：一个变量没有赋值  值就是und    一个函数没有返回值，也是返回und

赋值都是把栈空间的数据拿出来赋值给别人，一定是栈空间中的数据，不是堆空间中的数据

 给函数传递数据
function f(a,b) {  // a b叫形式参数  形参
    // 形参就是函数内部的局部变量
    return a+b;
}
 1 2叫实际参数  实参
var r = f(1,2); // 函数调用的过程就是实参向形参赋值的过程
console.log(r);

数据的存储

内存分堆内存和栈内存
在JS中，基本数据类型存储在栈中  引用数据类型存储在堆中

let和const声明变量

let

1）let声明的变量没有提升(let声明的变量也提升，仅仅是没有初始化)
2）let 配合 {} 也可以形成块级作用域
3）使用let声明的变量不会挂载到GO上
4）使用let不能重复声明

const

1）const是声明一个常量 没有提升
2) 也会形成块级作用域
3）使用const声明的常量不会挂载到GO上
4）使用const不能重复声明
5) const在声明常量时，必须赋值

闭包

一个不能被释放的栈空间，叫闭包

好处：延长一个局部变量的生命周期
坏处：造成内存泄漏

JS代码的同步执行

代码从上到下依次执行

同步：代码书写顺序和代码执行顺序一样
异步：代码书写顺序和代码执行顺序不一样
我们写的95%得代码都是同步代码

作用域链

描述找数据的链，现在自己的EC中找，如果找不到数据，就去自己的父EC中找，如果还找不到，就去父EC的父EC
中找，直到找到CE(G)，如果还找不到就报错。             
数据的查找机制