js的数据类型

  1. 原始数据类型
  • number 数值型
  • string 字符串型
  • boolean 布尔型
  • undefined 未定义型
  • null 空对象
  1. 引用数据类型
  • Array() 数组
  • Obj() 对象

    ==和===的区别

  1. ==

当两边的数据类型不同时，==会先把数据类型进行隐式的转换，之后再进行比较

  1. ===

在比较时不但会比较数据的值，还会比较数据的类型

js的六种假值

  • false
  • undefined
  • null
  • 0
  • NaN
  • “”

    undefined和null的区别

  1. 类型不一样

undefined为undefined型
null 为obj型

  1. 转化时值不同

Number(undefined)—>NaN
Number(null)—>0

  1. 产生的方式不同

null常见于：获取对象时类名错误
undefined常见于：声明变量但是没有赋值；形参没有接收到实参；函数没有设置返回值时，默认返回undefined;访问对象不存在的属性时。

什么是深拷贝，什么是浅拷贝

原始数据拷贝全部为深拷贝，
引用类型数据拷贝分为深拷贝和浅拷贝，当拷贝时只拷贝引用数据的地址时为浅拷贝，当拷贝时对每一个值都进行拷贝为深拷贝。

flex布局常用属性

  • display:flex;
  • justify-content:center,space-evenly,space-around,space-between;
  • align-items:center;

  • flex-direction:column;

    CSS的权重值

  • !important 10000

  • 内联样式 1000
  • ID选择器 100
  • 类，伪类，属性选择器 10
  • 标签选择器和伪元素选择器 1
  • 通用选择器和其他 0

    CSS3中的transition和animation的区别

  1. 指代不同

animation：用于设置六个动画属性
transition：用于设置四个过渡属性

  1. 特点不同

animation：需要绑定到选择器的@keyframe名称，规定完成动画的时间，没有设置时间不执行
transition：设置过渡效果的CSS属性的名称，设置完成过渡时间，没有设置时间不会产生过渡效果。

transform实现的效果及相关代码

  1. 位置改变 translate(),translate3D()
  2. 大小改变 scale()
  3. 角度改变 rotate()
  4. 为3D元素设置透视视图 perspective（）
  5. 倾斜角度 skew()

    new一个实例化对象经历的四个阶段：

  • 创建一个空的实例化对象
  • 改变构造函数中的this指向
  • 实例化对象自身的属性和方法

  • 返回实例化对象

    什么是闭包

    闭包就是可以实现读取其他函数内部变量的函数。
    因为只有函数内部的子函数才可以读取函数内部的局部变量，所以闭包可以理解成”定义在一个函数内部的全局函数”。
    在本质上，闭包是将函数内部变量与全局链接的桥梁。
    闭包的优点：

  • 避免全局变量被污染

  • 局部变量驻留在内存在，没有被销毁，函数外部可以通过闭包访问局部变量。

闭包的缺点：

  • 使用不当会造成内存泄露

闭包的作用：

  • 实现代码封装

    写一个简单的闭包

    ```javascript function test(){ var a = 0; function onClick(){
    1. a++
    console.log(a) } return onClick

} obj.onclick = test();

  1. <a name="FgcWH"></a>
  2. ## 自定义对象的方法
  4. - new Object()
  5. - 对象字面量
  6. - 使用构造函数自定义对象
  7. ```javascript
  8. //  自定义对象的第一种方式  new Object()
  9.     //  缺点： 不能用于重复创建具有相同模型（属性和方法）的多个对象。
  10.     // var one = new Object()  //空对象
  11.     // one.name = 'aaa'
  12.     // one.age = 12
  13.     // one.address = '开封'
  14.     // one.say = function () {
  15.     //   console.log('我来自开封');
  16.     // }
  17.     // one.say()
  19.     // var two = new Object()  //空对象
  20.     // two.name = 'nnn'
  21.     // two.age = 13
  22.     // two.address = '郑州'
  23.     // two.say = function () {
  24.     //   console.log('我来自郑州');
  25.     // }
  26.     // two.say()
  29.     // 自定义对象的第二种方式： 对象字面量
  30.     //以下三种写法完全等价
  32.     // 缺点： 不能用于重复创建具有相同模型（属性和方法）的多个对象。
  34.     // demo1:
  35.     var one = { name: 'a', age: 12 }
  37.     // demo2
  38.     var one = {}  //和new Object()等价，创建空对象
  39.     one.name = 'a'
  40.     one.age = 12
  42.     // demo3
  43.     var one = {
  44.       name: 'a',
  45.       age: 12
  46.     }
  49.       // 自定义对象的第三种方式：使用构造函数( 对象构造器）自定义对象
  50.      // 在ES5中，Student是自定义的对象, 在ES6中称为"类“
  51.     function Student(name,age,address){
  52.       this.name = name;
  53.       this.age = age
  54.       this.address = address
  55.       this.say = function(){
  56.         console.log('我是', this.name, '我来自',this.address);
  57.       }
  58.     }
  59.     // new出来的新对象称为实例化对象
  60.     var one = new Student('Alice',11,'郑州')
  61.     one.say()
  63.     var two = new Student("Jenny",13,'开封')
  64.     two.say()

什么是原型对象

所有的构造函数在初始化时，都会自动生成一个特殊的实例化对象，构造函数的prototype属性指向该对象，该对象成为原型对象，或者prototype对象。
proto属性：所有构造函数new出来的实例化对象，都有一个proto属性，该属性指向构造函数的原型对象。
原型对象的意义：实例化对象在访问属性和方法时，会先访问自身的属性和方法，如果自身不存在相对应的属性和方法，则会通过proto属性找到原型对象，如果原型对象上存在，则也能正确调用。
原型对象是为了实现继承。

什么是原型链

每一个函数的实例化对象都有一个proto属性，实例化对象的proto属性的指向也是原型，每一个proto下都有一个constructor跟proto属性，constructor指向该函数，而proto依次延伸，当函数继承时，会先在函数的prototype属性中找，找不到时，再继续在函数的原型对象中的proto下找，依次类推，形成原型链。

函数对象的call()、apply()、bind()方法

  1. function demo(a,b){
  2.     console.log(this)            //window
  3. }
  4. obj.onclick = function(){
  5.     demo.call(this,1,2)                    //obj
  6. }
  7. obj.onclick = function(){
  8.     demo.apply(this,[1,2])            //obj
  9. }
  10. obj.onclick = function(){
  11.     var test = demo.bind(this)        
  12.   test(1,2)                                        //obj
  13. }

什么是事件流

每一个事件发生时，都有一个从触发到结束的过程，这个过程被称为事件流。
事件流的三个阶段

  • 事件捕获：当某个DOM对象触发事件时，顶层对象document就会发出一个事件流，随着DOM树的节点向目标元素节点流去，直到达到事件真正发生的目标元素。在这个过程中，事件相应的监听函数是不会被触发的。
  • 事件目标：当达到目标元素后，执行该目标元素该事件相应的处理函数。如果没有绑定监听事件，就不执行。

  • 事件冒泡：从目标元素开始，往顶层元素传播。途中如果有节点绑定了相应的事件处理函数，这些函数会依次被触发。

    阻止事件冒泡

    e.stopPropagation()

    阻止浏览器默认行为

    e.proventDefault()

    什么是事件委托(事件代理)

    利用事件冒泡的特性，将本应该注册在子元素上的处理事件注册在父元素上，这样点击子元素时发现其本身没有相应事件就到父元素上寻找作出相应的事件操作。
    优点：

  • 管理的函数变少了

  • 可以给动态添加的DOM元素进行事件绑定。

    call()、apply()和bind()三者的区别

    call、apply、bind都是用来改变this指向的方法。
    call（）第一个参数是谁，this就指向谁
    apply（）的参数除this外都需要放到一个数组中。
    bind（）先传参和改变指向，形成新的函数。