JS基础介绍

javascript基础介绍

一、JS的初步介绍

1.JS:javascript 简称为JS 它是一门编程语言

2.JS与html,css的异同

1）相同：html,css,js代码都可以在浏览器中运行，html，css，js它们的运行环境是浏览器
2）不同点：html，css 不叫编程语言，js是编程语言；js的运行环境不只浏览器，还可以在其它的环境中支行。

3.JS能做什么？

1）开发网站
2）开发app
3）小程序
4）游戏开发 小程序游戏 网页游戏
5）写后端 node.js
6）嵌入式
7）区块链
…

4.JS三种写法

1）把js写在html文件中 学习时通常就写在script标签中(内部写法)
2）把JS写在JS文件中，然后在html文件中通过script标签引入 写项目时通常会把JS写在一个单独的文件中（外部写法）
3）把JS代码写在开始标签中，当成开始标签的属性（行内写法）

5.JS的基本语法

1）JS是区分大小写

        var a = 1; 
        var A = 2;

2）忽略空白符（空格 换行 tab）
3）语句分号可加可不加
4）注释

        // 单行注释  
        /* 多行注释 */

5）标识符 和 关键字

        var a = 110;   var 关键字   a变量名标识符

6）…

二、JS中的变量

1.数据

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

2.变量

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

3.定义变量

    var a = 110;  // 定义了一个变量  变量的名是a  变量的值是110;

4.在计算机中，=叫赋值运算符：

1+1 + 加号 左结合性
= 右结合性 从右向左

    var name = "wangcai";   把wangcai字符串值给name这个变量名所对应的内存空间

5.变量的分类：

1）全局变量（全局变量可以在函数内部都能访问到）
2）局部变量（局部变量只能在函数内部访问到）
分界点是：函数
只要把变量写在函数里面就是局部变量，只要写在函数外面就是全局变量。

三、JS中的数据类型

1.为什么需要数据类型：

age 10
id 3456783456783456789
为了更加合理使用内存空间，基本上所有的编程语言中都提出
数据类型的概念，研究针对不同的数据，分配不同的空间。

2.JS中的数据类型：

针对不同的数据类型，分配不同的空间。

基本数据的类型：

（1）number

1）number是一个数据类型，这个数据类型对应的值有无数个。
2）在JS中number数据类型是不分整数和小数 都是number
3）可以通过typeof查看一个变量值的数据类型
console.log(typeof a);
4）最大值 和 最小值

      console.log(Number.MAX_VALUE)
      console.log(Number.MIN_VALUE)

5）number可以通过不同进制显示
10进制 2进制 16进制 8进制
6）NaN Not a Number 不是一个数字

      console.log("abc"*100);

7）JS中不要对小数运算 要运算先转成整数

      var a = 110;  int a = 110;

（2）string

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

（3）boolean

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

（4）undefiend 没有值

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

（5）null 没有值

引用数据类型：

object 对象：
array 数组
function 函数 在JS中函数也是一种数据类型

3.JS中数据类型转化

1）隐式类型转化（静悄悄，不知不觉转化 ）

        	var res = 123 + "abc";  // 123隐式转化成字符串
            console.log(res);  // 123abc
            console.log(typeof res);  // string

在JS中，0 -0、""、undefiend、null的值转成false，其它值都转成true。

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

四、代码段

1.一个script标签就是一个代码段。

JS代码在执行时，是一个代码段一个代码段执行。

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

1）预编译:提升
把加var的变量进行提升 变量声明会提升 变量的赋值是不会提升
提升到了代码段最前面
把使用function声明的函数进行提升 提升的是整个函数声明
2）代码执行
一行一行执行
3）定义变量和声明变量：
定义变量：

        var a = 110;   // 定义 = 声明+赋值

声明变量：

        var a = 110;   // 说的声明仅仅是说var a   后面是赋值

五、初步了解执行上下文

1）执行上下文

EC（ Execute Context）

2）EC的作用

给代码提供数据

3）全局代码 函数外面的代码叫全局代码

函数代码 一个函数就是一个局部代码

4）全局执行上下文：

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

5）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)
    访问一个对象上不存在的属性，结果就是undefined
    console.log(window.a) // undefined

七、EC（G），EC（f），VO，AO，GO

1） EC(G) 全局执行上下文

存储全局的加var 加function的数据存储在VO中

2）VO 变量对象

存储的全局的加var 或 加function

3）EC(f) 函数执行上下文

存储局部的加var 或 加funciton的局部数据

4）AO 活动对象

存储局部的加var 或 加function的局部数据

5）GO 全局对象

默认情况下，里面就存储了很多东西。全局的数据，加Var的全局数据，加functon的全局数据，不加var的变量都会存储到GO中的

八、函数

EC（G）在JS中定义函数有两种形式：函数定义、函数表达式。

1）函数定义

定义 = 声明 + 赋值
f是函数名 ()是函数特有的标识 {} 是函数体

    function f() {
        console.log("hello")        
    }

2）函数调用

    f(); // 调用函数时，就会把函数体中的代码都执行了

3）函数的返回值

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

4）一个函数如果没有返回值，默认返回undefiend

    function f(){
    }
    console.log(f()); // undefined

5）给函数传递数据

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

九、数据的存储

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

十、let和const声明变量

声明变量使用let 声明常量使用const

let:

1）let声明的变量没有提升(或者说let声明的变量也提升，仅仅是没有初始化)

        console.log(a);
        let a = 110;  //  Cannot access 'a' before initialization

2）let 配合 {} 也可以形成块级作用域

        if(true){
            var a = 110; // 全局变量
            // b只能在当前的{}中被访问到 出了块就访问不了
            let b = 666; // let + {} 形成块级作用域
        }
        console.log(b); // b is not defined

3）使用let声明的变量不会挂载到GO上

        let a = 110;
        console.log(window.a); // undefined 访问一个对象上没有属性，得到的就是und

4）使用let不能重复声明

        let a = 1;
        let a = 2;
        console.log(a); // Identifier 'a' has already been declared

const:

1）也没有提升

        console.log(a);
        const a = 1;  //  Cannot access 'a' before initialization

2) 也会形成块级作用域

        if(true){
            const a = 111;
        }
        console.log(a); //  a is not defined

3）使用const声明的常量不会挂载到GO上

        const a = 1;
        console.log(window.a); // undefined

4）使用const不能重复声明

        const a = 1;
        const a = 2;
        // Identifier 'a' has already been declared
        console.log(a);

5)const在声明常量时，必须赋值

        const a;
        a = 1;
        console.log(a)