js
数据类型:
1、基本类型:String、Number、boolean、undefined、null
2、对象类型:Object(任意对象)、Function(一种特殊的对象)、Array(一种特别的对象,内部数据是有序的)
判断方法:
1、typeof(返回数据类型的字符串表达)
可以判断:undefined、数值、字符串、boolean、function
不能判断:null和Object、Object和Array
2、instance:判断对象的具体类型
3、=== 可以判断:undefined、null
var b1 = {
b2: [1, 'abc', console.log],
b3: function () {
console.log('b3')
return function () {
return 'xfzhang'
}
}
}
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
console.log(typeof b1.b2, '-------') // 'object'
console.log(typeof b1.b3==='function') // true
console.log(typeof b1.b2[2]==='function')
b1.b2[2](4)
console.log(b1.b3()())
undefined和null的区别:undefinded代表定义未赋值,null定义并且赋值,其值为null
什么时候给变量赋值为null:
1、初始化的时候,表明该值之后将赋值为对象
2、结束前,让它成为垃圾对象(以便被垃圾回收器回收)
什么是数据:数据是存储在内存中的东西,本质上是0、1序列
数据的特点:可传递性,可运算,一切皆数据,内存中操作的目标:数据,算术运算、逻辑运算、赋值、运行函数
什么是内存:内存条通电后产生可以存储和数据的空间(临时空间),以小块内存的2个数据(地址值、内部存储的数据)
内存的分类:
栈:全局变量、局部变量
堆:对象
什么是变量:可以变化的量,由变量名和变量值构成,每个变量都对应一块小区域,变量名用于查找用户,变量值就是内存存储的数据
内存、变量、数据之间的关系:内存用来存放数据,变量用于表示数据
var = xxx
当xxx是基本数据类型的时候,保存的就是这个数据,xxx是对象的时候,保存的时候对象的地址值(xxx是一个变量,保存的xxx的内存内容,可能是基本数据、也可能是地址值)
引用变量赋值的:
多个引用变量指向同一个对象,通过一个变量修改对象内部的数据,另外的变量看到是修改之后的数据
<script type="text/javascript">
var obj1 = {name: 'Tom'}
var obj2 = obj1
obj2.age = 12
console.log(obj1.age) // 12
function fn (obj) {
obj.name = 'A'
}
fn(obj1)
console.log(obj2.name) //A
var a = {age: 12}
var b = a
a = {name: 'BOB', age: 13}
b.age = 14
console.log(b.age, a.name, a.age) // 14 Bob 13
function fn2 (obj) {
obj = {age: 15}
}
fn2(a)
console.log(a.age)
</script>
js引擎如何管理内存:
内存的声明周期:
分配好内存区域,得到使用权,存储数据,可以反复进行操作,释放内存
释放内存:
局部变量:函数执行完自动释放
对象:称为垃圾对象,垃圾回收期回收
什么是对象:多个数据的封装体,用来保存多个数据的容器,一个对象代表现实世界中的一个事务
为什么要使用对象:统一管理多个对象
对象的组成:
属性:属性名(字符串)、属性值(任意类型)
方法:一种特别的属性(属性值是函数)
如何访问对象内部的数据:
1、对象.属性名
2、['属性值']
<script type="text/javascript">
var p = {
name: 'Tom',
age: 12,
setName: function (name) {
this.name = name
},
setAge: function (age) {
this.age = age
}
}
p.setName('Bob')
p['setAge'](23)
console.log(p.name, p['age'])
</script>
什么时候必须使用['属性名']的方式:1、属性名包特殊字符的时候,2、属性名用变量的时候
<script type="text/javascript">
var p = {}
//1. 给p对象添加一个属性: content type: text/json
// p.content-type = 'text/json' //不能用
p['content-type'] = 'text/json'
console.log(p['content-type'])
//2. 属性名不确定
var propName = 'myAge'
var value = 18
// p.propName = value //不能用
p[propName] = value
console.log(p[propName])
</script>
什么是函数:实现特定功能的多条语句的集合体,只有函数是可以执行的,其他类型的数据都是不可执行的
为什么要使用函数:提高代码的复用性,便于阅读交流
如何定义函数:1、函数声明 2、表达式
var obj = {}
function test2 () {
this.xxx = 'atguigu'
}
// obj.test2() 不能直接, 根本就没有
test2.call(obj) // obj.test2() // 可以让一个函数成为指定任意对象的方法进行调用
console.log(obj.xxx)
什么函数才是回调函数: 1、由自己定义的,2、自己没有进行调用,3、最终函数执行了
常见的回调函数:1、dom事件的回调函数, 2、定时器的回调函数, 3、ajax的异步回调函数, 4、声明周期的回调函数
IIFE:全称: Immediately-Invoked Function Expression
作用:
隐藏实现,不污染全局命名空间,用它来编码js模块
(function () { //匿名函数自调用
var a = 3
console.log(a + 3)
})()
(function () {
var a = 1
function test () {
console.log(++a)
}
window.$ = function () { // 向外暴露一个全局函数
return {
test: test
}
}
})()
$().test() // 1. $是一个函数 2. $执行后返回的是一个对象
this是什么:
1、任何函数本质上都是通过某个对象来调用的,如果没有直接指定就是window
2、所有函数的内部都有一个变量this,它的值是调用函数的当前对象
Person("red"); //this是谁? window
var p = new Person("yello"); //this是谁? p
p.getColor(); //this是谁? p
var obj = {};
p.setColor.call(obj, "black"); //this是谁? obj
var test = p.setColor;
test(); //this是谁? window
函数的prototype属性:
每个函数都有一个prototype属性,它默认指向一个Object空对象(原型对象)
原型对象有一个属性constructor,它指向函数对象
给原型中添加属性(一般都是方法):函数所有的实例对象中自动拥有原型对象中的属性
<script type="text/javascript">
// 每个函数都有一个prototype属性, 它默认指向一个Object空对象(即称为: 原型对象)
console.log(Date.prototype, typeof Date.prototype)
function Fun () {
}
console.log(Fun.prototype) // 默认指向一个Object空对象(没有我们的属性)
// 原型对象中有一个属性constructor, 它指向函数对象
console.log(Date.prototype.constructor===Date)
console.log(Fun.prototype.constructor===Fun)
//给原型对象添加属性(一般是方法) ===>实例对象可以访问
Fun.prototype.test = function () {
console.log('test()')
}
var fun = new Fun()
fun.test()
</script>
每个函数function都有一个prototype,即显示原型(属性)
每个实例对象都有一个__proto__,可以成为隐式原型(属性)
对象的隐式原型值=构造函数的显示原型值
函数的prototype属性:在定义函数时候自动添加,默认是一个Object空对象
对象的__proto__属性:创建对象的时候自动添加,默认值是构造函数的prototype属性值
<script type="text/javascript">
//定义构造函数
function Fn() { // 内部语句: this.prototype = {}
}
// 1. 每个函数function都有一个prototype,即显式原型属性, 默认指向一个空的Object对象
console.log(Fn.prototype)
// 2. 每个实例对象都有一个__proto__,可称为隐式原型
//创建实例对象
var fn = new Fn() // 内部语句: this.__proto__ = Fn.prototype
console.log(fn.__proto__)
// 3. 对象的隐式原型的值为其对应构造函数的显式原型的值
console.log(Fn.prototype===fn.__proto__) // true
//给原型添加方法
Fn.prototype.test = function () {
console.log('test()')
}
//通过实例调用原型的方法
fn.test()
</script>
原型链:访问一个对象的属性时候:先在自身查找,找到返回,没有找到,则沿__proto__这条链向上查找,找到就返回,如果最终没有找到,返回undefined