变量的基本类型
原始类型: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() // 获取秒