JS基础知识（上）

值类型

var a = 100
var b = a
a = 200
console.log(a) //100

引用类型

var  a = { age:20}
var b = a
b.age = 21
console.log(a.age) //21

typeof 运行符

typeof    undefied  //undefied
typeof    'abc'  //String
typeof    123  //Number
typeof    true // Boolean
typeof    {}   //object
typeof    [] //object
typeof    null  //object
typeof    console,log  //function

变量计算 ----- 强制类型转换

1 字符串拼接
2 ==运算符
3 if语句
4 逻辑运算

1字符串拼接
 var  a = 100+10    //110
 var  b = 100+'10'  //10010


2 == 运算符
100 == ‘100’  //true
0  ==  ''         //true


3 if 语句

var  a = true
if (a) {
  //  ....
}



var  b = 100
if  (b) {
 //....
 }

var  c = ' '
if (c) {
 //...
}


4 逻辑运算符
console,log(10 && 0) //0
console.log( ''|| 'abc') //'abc'
console.log(!window.abc)  //true

//判断一个变量会当做true还是false
var a = 100
console.log (!!a)

JS中使用typeof能够得到的类型（面试题）

typeof  undefined  //undefined
typeof  'abc'        // String
typeof   124        //Number
typeof   true        //Boolean
typeof   {}           //Object
typeof   []            //Object
typeof  null          //Object
typeof  console.log  //function

何时使用 === 何时使用==

if (obj.a == null) {
   //这里相当于  obj.a === null  ||  obj,a ===undefined ,简写形式
   //这是jQuery源码中推荐的写法
}

//==用于一般比较，===用于严格比较，==在比较的时候可以转换数据类型，===严格比较，只要类型不匹配就返回flase

JS中有哪些内置函数----数据封装对象

Object 
Number
String
Boolean
Date
Array
RegExp
Error
Function

如何理解JSON？

JSON是Js对象而已
当然了JSON也是一种数据格式

'' == 0  //true
'' === 0 //false
null == undefined  //true
null === undefined  //false
100 == '100' //true
100 === '100' //false

构造函数

function  Foo (name,age ) {
        this.name = name
        this.age =age 
        this.class = 'class-1'
        //return this  默认有这一行
        }
        //创建对象
        var f = new  Foo ('zhangsan',20)
        

构造函数扩展

var  a = [] 是 var a = new Array()的语法糖
var  b = {} 是  var b  = new  Object()的语法糖
function  Foo(){ .. }其实var foo = new function （...）

使用instanceof判断一个函数是否是某个变量的构造函数

原型规则和示例

所有的引用类型（数组，对象，函数），都具有对象特性，级可扩展属性（除了“null”以外）

var obj = {};
obj.a = 100;


var arr = [];
arr.a = 100;


function  fn () {}
fn.a = 200;


//实例对象里面都有一个__proto__的隐士原型
console.log(obj.__proto__);
console.log (arr.__proto__);
console.log(fn.__proto__)



//实例对象的隐士原型指向他构造函数的显示原型
console.log(obj.__proto__ ===Object.prototype) //true



//所有的引用类型（数组，对象，函数）都有一个__proto__属性，属性值是一个普通的对象


所有的引用类型（数组，函数，对象）__proto__属性值指向他的构造函数的“prototype”属性值

当试图得到一个对象的某个属性时，如果这个对象本身没有这个属性，那么就去他的__proto__（也就是他的构造函数的prototype）中去寻找

//构造函数
function  Foo(name,age) {
  this.name = name
  }
  Foo.prototype.alertName = function () {
    alert (this.name)
  }
//创建示例
var   f = new   Foo ("张三”，90)
f.printName = function () {
  console.log(this.name)
}

//测试
f.printName()
f.alertName()

循环对象自身的属性

var  item 
for (item in f) {
 //高级浏览器已经在for in 中屏蔽了来之原型的属性
 //但是这里建议大家还是加上这个判断，保证程序的健壮性
if (f.hasOwnProperty(item)) {
  console.log(item)
}
}

instanceof

用于判断引用类型属于哪个构造函数的方法

如何判断一个变量是数组类型

var  arr = []
arr insranceof  Array  //true

typeof  arr  //Object  typeof 是无法判断是否是数组的

写一个原型链继承的例子

(先理解这个例子，但是面试的千万不要这么写，这么写面试官会给你减分)
// 动物
function Animal () {
  this.eat = function() {
    console.log("animal eat")
   }
}


//狗
function Dog () {
 this.bark = function () {
 console.log(“dog  bark”)
 }
}

Dog.prototype = new  Animal()

//哈士奇
var   hashiqi = new  Dog()

描述new 一个对象的过程

1 创建一个新对象
2 this指向这个新对象
3 执行代码，既对this赋值
4 返回this


1 创建这个新对象
2 this指向这个新对象
3 执行代码，既返回this赋值
4 返回this

写一个原型继承的例子

function  Elem(id) {
   this.elem = document.getElementById(id)
   }
Elem.prototype.html = function (val) {
   var  elem = this.elem
    if (val) {
        elem.innerHtml = val
        return this
}else {
   return  elem.innerHTML
}
}


Elem.prototype.on = function  (type,fn) {
var  elem = this.elem
elem.addEventListener(type,fn)
}

var  div1 = new  Elem('div1')

作用域和闭包

fn ()
function fn(){
//声明
}


var   fn = function () {
 // 表达式
}