题目一
- JS中使用
typeof能得到哪些类型 - 何时使用
==何时使用=== - JS中有哪些内置函数
RegExp, Array, Object, Boolean, String, Number, Function, Date, Math
- JS变量按照存储方式区分为哪些类型 , 并描述其特点
- 如何理解
JSON-
JSON只不过是JS对象, 也是一种数据格式JSON.stringify()JSON.parse()
-
知识点
- 变量类型
- 值类型
var a = 100
var b = a
a = 200
console.log(b) // 100 值类型,结果还是原来的值
- 引用类型
[数组 对象 函数]
var a = {age: 20}
var b = a
b.age = 21
console.log(a.age) // 21 引用类型 只是把值放在了一个地址, 然后通过指针指向哪个地址
值类型&&引用类型
typeof 运算符
// 总共有 6 种结果 typeof 只能详细区分值类型, 对于引用类型区分为 object & function
typeof undefined // undefined
typeof 'abc' // string
typeof 123 // number
typeof true // boolean
typeof {} // object
typeof [] // object
typeof null // object
typeof console.log // function
- 变量计算
- 强制类型转换
- 字符串拼接
- == 运算符
- if 语句
- 逻辑运算
var a = 100 + 10 // 110
var a = '100' + 10 // '10010'
100 == '100' // true 转为字符串
0 == '' // true 转为false
null == undefined // true 转为 boolean false
var a = true
if (a) {//...}
var b = 100
if (b) {//...}
var c = ''
if (c) {//...}
console.log(10 && 0) // 0
console.log( '' || 'abc') // 'abc'
console.log(!window.abc) // true
// 判断一个变量被当做 true 还是 false
var a = 100
console.log(!!a)
题目二
- 如何准确判断一个变量是
数组类型变量 instanceof Array
var arr = [] arr instanceof Array // true - 写一个
原型链继承的例子function Person(name, sex){ // todo ... this.name = name; this.sex = sex; } Person.prototype.getName = function(){ // todo ... console.log('name: ' + this.name); }; function Male(name, sex, age){ //todo ... Person.call(this, name, sex); this.age = age; } //todo ... Male.prototype = Object.create(Person.prototype); Male.prototype.constructor = Male; Male.prototype.getAge = function(){ //todo ... console.log( 'age: ' + this.age); }; var ruoyu = new Male('yym', '男', 24); ruoyu.printName(); - 描述
new一个对象的过程
知识点
- 构造函数
function Foo(name, age) { // 构造函数首字母大写
// 1
// 2
this.name = name || '1'
this.age = age || 23
this.class = 'class1'
// 3
}
var f = new Foo('yym', 24)
var f1 = new Foo // 如果没有传参数, 不用带括号
new 做了什么? new 默认做了这些, 不需要你做一遍
1. this = {}
2. this.__proto__ = Foo.prototype
3. return this
- 构造函数-扩展
var a = {} 其实是 var a = new Object() 的语法糖
var a = [] 其实是 var a = new Array() 的语法糖
function Foo() {...} 其实是 var Foo = new Function(...)
使用 instanceof 判断一个函数是否是一个变量的构造函数
- 原型规则
- 所有的引用类型 (数组 对象 函数) , 都具有对象特性, 即可自由扩展属性 (
null除外)
var obj = {}; obj.a = 100
var arr = []; arr.a = 100
function fn () {}
fn.a = 100
- 所有的引用类型, 都有一个
__proto__ (隐式原型)属性, 属性是一个普通的对象
obj.__proto__
arr.__proto__
fn.__proto__
- 所有的函数, 都有一个
prototype (显式原型)属性, 属性值也是一个普通的对象
console.log(fn.prototype)
- 所有的引用类型,
__proto__属性值指向它的构造函数的prototype属性值
obj.__proto__ = Object.prototype
- 当试图得到一个对象的某个属性时, 如果这个对象本身没有这个属性, 那么会去它的
__proto__(即它的构造函数的prototype) 中寻找
function Foo(name, age) {
this.name = name
}
Foo.prototype.alertName = function() {
console.log(this.name)
}
// 创建示例
var f = new Foo('yym')
f.printName = function() {
console.log(this.name)
}
f.printName() // yym
f.alertName() // f.__proto__
console.log(f.__proto__ === Foo.prototype) // true
- 循环对象自身的属性
var item
for (item in f) {
// 高级浏览器已经在for in 中屏蔽了来自原型的属性
// 建议加上这个判断, 保证程序的健壮性
if (f.hasOwnProperty(item)) {
console.log(item)
}
}
- 原型链
// 封装 DOM 查询, 原型链例子:
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')
div1.html('<a>你好</a>').on('click', function() {
this.style.color = 'red'
})
function Foo(name, age) {
this.name = name
}
Foo.prototype.alertName = function() {
console.log(this.name)
}
var f = new Foo('yym')
f.printName = function() {
console.log(this.name)
}
f.printName() // yym
f.alertName() // f.__proto__
f.toString() // f.__proto__.__proto__
原型链
原型链总览
indtanceof
- 用于判断
引用类型属于哪个构造函数的方法
f instanceof Foo // true
判断逻辑: f 的 __proto__ 一层一层往上, 能否对应到 Foo.prototype
f instanceof Object // true
