变量的基本类型
原始类型：number,string,boolean,null,undefined
引用类型：Object,Array,Function
typeof 返回的值(返回的是字符串)
number,string,boolean,object,undefined,function
{} [] null 返回的是object
使用函数判断具体数据类型：
function uniq(item){
var itemType = Object.prototype.toString.call(item)
if (typeof item == 'object') {
if(item==null){
console.log('null')
}else if(itemType =="[object Array]"){
console.log('Array')
}else{
console.log('Object')
}
}else{
console.log(typeof item)
}
}
var str = undefined
uniq(str)
instanceOf 判断变量是属于哪一种类型，返回的值是boolean
强制类型转换
字符串拼接
==
赋值语句
逻辑运算
if语句
===
== 若是判断值是不是 null和undefined
if(obj.a == null){}
等价于
if(obj.a === null||obj.a===undefined){}
js中的内置函数
Object,Array,Boolean,Number,String,Function,Date,RegExp,Error
如何理解JSON
JSON是JS的一个对象
JSON.stringify({a:10,b:20})
JSON.parse('{"a":10,"b":20}')
原型和原型链:
全部的引用类型都具备对象特色,即自由扩展属性
全部的函数都有一个显示类型的属性，prototype指向构造器
全部的引用类型都有一个_proto_属性，属性只是一个普通对象
new 一个函数的过程
新建一个对象
this指向这个对象
给this赋值，
返回this
prototype 引用
Father.prototype.lastName = 'xiaogeng'
function Father(name,age){
this.name = name;
this.age = age;
}
var father = new Father('genggeng',25)
Son.prototype = father
Son.prototype.car = 'benz'
function Son(grade){
this.grade = grade
}
var item
for(item in f){
if(f.hasOwnProperty(item)){
console.log('是自己属性')
}
}
var son = new Son('3年级');
console.log(son);
继承
原型链继承
Grande.prototype.lastName = "benz"
function Grande(name,age){
this.name = name;
this.age = age
}
var grande = new Grande()
Father.prototype = grande;
function Father(grade){
this.grade = grade
}
var father = new Father("xiaogeng",24,'大四')
console.log(father)
call/apply借用：该方法的缺点是不能继承原型上的东西
Grande.prototype.lastName = "benz"
function Grande(name,age){
this.name = name;
this.age = age
}
function Father(name,age,grade){
Grande.call(this,name,age)
this.grade = grade;
}
var father = new Father('xiaogeng',24,'大四')
console.log(father)
共享原型：不能修改原型
Grande.prototype.lastName = "benz"
function Grande(){
}
function Father(){
}
function inhert(Tagert,Origin){
Tagert.prototype = Origin.prototype
}
inhert(Father,Grande);
var father = new Father()
圣杯模式
Grande.prototype.lastName = "benz"
function Grande(){
}
function Father(){
}
function inhert(Tagert,Origin){
function F(){}
F.prototype = Origin.prototype
Tagert.prototype = new F()
Tagert.prototype.constructor = Tagert //把Target的构造函数指向归位
Tagert.prototype.uber = Origin.prototype //为了让咱们知道Target真正继承自谁
}
inhert(Father,Grande);
var father = new Father()
function test(){
//函数声明
}
var text = function(){
//函数表达式
}
//在后面添加执行符，函数表达式是能够执行的，可是函数声明不能被执行，由于函数声明会被先提高
//执行期上下文：每一个javascript函数都是一个对象，对象中有些属性咱们能够访问，但有些不能够，这些属性仅供JavaScript引擎存取[[scope]]就是其中一个；[[scope]]就是我所说的做用域，其中存储了运行期上下文的集合;[[scope]]中存储的执行期上下文对象的集合，这个集合呈链式链接，咱们把这种链式链接叫作做用域链
//范围：一段script标签或者函数内，会产生一个执行期上下文
//全局：函数定义，函数声明
//函数：变量定义，函数声明、this、arguments
this //指向在定义时没法肯定，在执行时才能确认
var a = {
name:'a',
fn:function(){
console.log(this.name)
}
}
a.fn()
a.fn.call({name:'b'})
var fn1 = a.fn
fn1() //this指向window
// 做为构造函数执行，this指向new出来的对象
// 做为普通函数执行，this指向window
// call和apply、bind，this指向被绑定的对象
// 对象中的this,指向最近调用的一级
//做用域:javascript没有块级做用域
if(true){
var a = 2;
//不推荐这种写法，由于这一样是定义在全局的，可是不易读
}
//js的做用域分为全局做用域和函数做用域，为了防止污染全局变量，函数当定义在函数做用域内部
//做用域链:
var a = 100;
function fn(){
var b = 50;
function fn2(){
var c = 300
console.log(a) //a是自由变量
console.log(b) //b是自由变量
console.log(c)
}
}
// 同步和异步
//"同步模式"就是上一段的模式，后一个任务等待前一个任务结束，而后再执行，程序的执行顺序与任务的排列顺序是一致的、同步的.是一种阻塞模式
// "异步模式"则彻底不一样，每个任务有一个或多个回调函数（callback），前一个任务结束后，不是执行后一个任务，而是执行回调函数，后一个任务则是不等前一个任务结束就执行，因此程序的执行顺序与任务的排列顺序是不一致的、异步的。是非阻塞的
//异步的使用场景： 须要等待就须要异步
//定时任务： setTimeOut,setInterval
//网络请求: ajax请求，动态加载
//事件
var today = new Date();
today.getTime() //获取毫秒数
today.getFullYear() //年
today.getMouth() // 月（0-11）
today.getDate() // 日（0-31）
today.getHours() //小时(0-23)
today.getMinutes() //分钟（0-59）
today.getSeconds() // 获取秒