javascript 基础

数据类型

分类

1. 基本（值）类型
   String: 任意字符串
   Number: 任意数字
   boolean: true/false
   undefined: undefined
   null:null
   2.对象(引用) 类型
   Object 任意对象
   Function 一种特别的对象(可以执行)
   Array: 一种特别的对象(数值下标,内部数据有序)

判断

typeof 返回数据类型的字符串表达
可以判断 undefined,number,string,boolean,function
不能判断:null Object Array
instanceof 判断对象的具体类型
=== 不会做数据转换 值 类型必须完全相同 / ==
可以判断 undefined,null

1.undefined 与 null 的区别
undefined代表定义未赋值
null定义并赋值了 只是值为null
2. 什么时候给变量赋值为null呢
初始赋值,表明将要赋值为对象
结束前 让对象成为垃圾对象(被垃圾回收器回收)
3. 严格区别变量类型与数据类型
数据的类型
基本类型
对象类型
变量的类型(变量内存值的类型 )
基本类型 保存的是基本类型的数据
引用类型 保存的是地址值
代码示例

 var a;
    console.log(a,typeof a,a===undefined)//undefined(数据类型)  "undefined"(数据类型的字符串表达式) true
    console.log(typeof a === 'undefined') // true
    console.log(a == (typeof a)) //false
    console.log(a == undefined) // true

    a=3;
    console.log(typeof a === 'number') //true
    a= "yoke"
    console.log(typeof a =="string") //true  s小写
    a= true
    console.log(typeof a =="boolean") //false
    a=null
    console.log(typeof a,a===null)

    var b1 ={
        b2:[1,"abc",console.log],
        b3:function (){
            console.log('b3')
            return function (){
                return "yoke"
            }
        }
    }
    // Object 构造函数
    console.log(b1 instanceof Object, b1 instanceof Array) //true false
    console.log(b1.b2 instanceof Array,b1.b2 instanceof Object) // true true
    console.log(b1.b3 instanceof Function,b1.b3 instanceof Object) // true true
    // A instanceof B  A是不是类型的实例

    console.log(typeof b1.b3 === 'function') // true
    console.log(typeof b1.b2[2] === 'function') //true
    b1.b2[2](4) // =console.log(4)
    //b1.b3()
    console.log(b1.b3()())

数据，变量，内存

数据

存储在内存中代表特定信息的一串编码 本质上010100...
特点
    可传递,可运算
一切皆数据
内存中所有操作的目标:数据
    算数运算
    逻辑运算
    赋值
    运行函数

变量

变量名 变量值 组成
每个变量都对应的一块小内存,变量名用来查找对应的内存 ，变量值

变量赋值问题

    * n个引用变量指向同一个对象,通过一个变量修改对象内部数据,其它所有变量看到的
    是修改之后的数据
    * 2个引用变量指向同一个对象,让其中一个引用变量指向另外一个对象,另一个引用变
    量仍然指向前一个对象
    ps:(在函数中指向一个对象时 当函数执行完毕时会自动释放函数内部的变量 这个对象将变为垃圾对象)

内存

内存条通电以后 产生的可存储数据的空间(临时的)
释放内存 清空内存中的数据 标识内存可以再分配使用
一块小内存的两个数据
    内部存储的数据
    地址值
内存的分类
    栈: 全局变量 局部变量
    堆: 对象 

三者关系

内存用来存储数据的空间
变量是内存的标识

 /*
        在js调用函数时 传递变量参数时,是值传递 还是引用传递
           理解:  基本值/地址值  传递
                 可能是值传递,也可能是引用传递(地址在传递)
     */
    let a = 3
    function fn(a) {
        a = a+1  // 2. 传递 3 操作 3+1  对等号的左边的a 是灰色的 没有用到 他的值为4

        // console.log(a)
    }
    fn(a)  //  1. 读取a的值 3
    console.log(a) // 3

    let obj ={name:'yoke'}
    function fn2(obj){
        obj.name="yoke1" // 此时传递地址值 会发生改变
    }
    fn2(obj)
    console.log(obj)

    // js 内存管理
    /*
        1. 内存生命周期
            分配小内存空间 得到使用权
            存储数据, 可以反复进行操作
            释放小内存空间
         2. 释放内存
            局部变量: 函数执行完 自动释放
            对象: 成为垃圾对象 垃圾回收器回收
            全局变量 暂不释放


     */
    let  b =3
    var ob1={ name:123}
    ob1 =null
    function fn(){
        var b2 = {}
        console.log(b2)
    }
    fn() // b2 自动释放 b2 所指向的对象 在后面的某个时刻由垃圾回收器回收释放

对象

1. 对象
    多个数据的封装体
    保存多个数据的容器
    一个对象可以代表一个事物
2. 使用对象
    统一管理多个数据
3. 对象的组成
  属性 属性名 和 属性值
  方法 一种特别的属性 属性值为函数
4. 访问
 .属性名
  ['属性名'] 通用
        属性名包含册数字符 - 空格
        属性名不确定

 let p ={
        name:"yoke",
        age:12,
        setName: (name)=> {
            console.log(this)
            this.name =name
        },
        setAge: function (age){
            this.age =age
        }
    }
    p.setAge(80)
    p['setName']("123")
    console.log(p)

    let obj ={}
    obj['content-type'] = 'text'
    let propName = 'myage'
    let value =181
    // obj.propName =value
    obj[propName] = value
    console.log(obj)

函数

基本函数

调用函数的方法
* test(): 直接调用
* obj.test(): 通过对象调用
* new test(): new调用
* test.call/apply(obj): 临时让test成为obj的方法进行调用

function  checkAge (age) {
        if(age<18){
            console.log('未成年')
        }else if (age> 60){
            console.log('算了吧')
        }else {
            console.log('刚好')
        }
    }
    checkAge(16)
    checkAge(60)

    const fn2 = function () { //函数

    }
    let obj = {}
    function test2 () {
        this.name ="123"
    }
    test2.call(obj)
    console.log(obj)

回调函数

定义的函数 自己不调用 但是最终执行了 定时器 ajax请求 dom事件回调

IIFE Immediately-Invoked Function Expression

/*
        Immediately-Invoked Function Expression
        ()() 第一个()  里面写一个没有名字的函数

        好处
            隐藏实现
            不会污染外部命名空间
     */


    (function (){  //匿名函数自调用
        let a =3
        console.log(a+3)
    })()
    let a = 4;
    (function (){
        let  a=1
        function test(){
            console.log(++a)
        }

        window.$=function (){
            return{
                test:test
            }
        }
        $().test()
        $().test()
    })()
    $().test()

函数this

 /*
        任何函数本质上都是通过某个对象来调用的，没指定 this就是window
        所有函数内部都有一个变量 this
        它的值是调用函数的当前对象
      this 指向
          fn() window
          obj.fn()  obj
          new fn() 新创建的对象
          fn,call(obj) obj


     */
    function Person(color) {
        console.log(this)
        this.color =color
        this.getColor =function (){
            console.log(this)
            return this.color
        }
        this.setColor =function (color){
            console.log(this)
            this.color =color
        }
    }
    Person("red") // this 指向Window
    let p = new Person("yellow")
    p.getColor() // p
    var obj ={}
    p.setColor.call(obj,"black")  // obj