// 全局作用域下有 num1 : 55 ,num2: 66,俩个变量
var num1 = 55
var num2 = 66
function f1(num, num1) {
// 根据传入的参数，变量的提升，预编译
// 函数作用域下有 num：55 ，num1：66
// var num = 55
// var num1 = 66
// 此时变量num和num1被改为了100
num = 100
num1 = 100
// 根据作用域链，函数内部无num2变量，往上一级作用域寻找，变量提升，全局变量的num2被改为了100
num2 = 100
console.log(num) //100
console.log(num1) //100
console.log(num2) //100
}
f1(num1, num2)
console.log(num1) //55
console.log(num2) //100，全局变量num2在函数种被改为了100
console.log(num); //not define 报错 全局作用域下无num属性
function Person(name, age, salary) {
// 函数作用域下有 name age salary 三个变量
this.name = name
this.age = age
this.salary = salary
}
function f2(person) {
// f2的作用域下 person: p
//var person = p
// 此时person和p指向堆内存中的同一个Person对象
person.name = 'ls' //改变了堆内存的Person对象的name值
// person和p的作用域下：name: aa, age: 18, salary: 10
person = new Person('aa', 18, 10) //将person指向新的Person对象
}
// p的作用域下 name: zs, age: 18, salary: 1000
var p = new Person('zs', 18, 1000)
console.log(p.name) //'zs'
f2(p)
console.log(p.name) //'ls' 此时打印的仍然是堆内存中第一个Person的name值
变量提升
js引擎在代码正式执行之前会做一个预处理的工作:
1．收集变量
2．收集函数
依据:
var ：将var后边的变量定义但是不赋值 var username = undefined;
function(){} 提前定义该函数
变量的提升是变量名的提升,函数提升是整体的提升
变量与函数同名，提升以函数为准
console.log(username) //undefined
var username = 'kobe'
console.log(username) //kobe
fun() //fun()
function fun() {
console.log('fun()')
}
function Foo() {
getName = function () {
console.log(1)
}
return this
}
Foo.getName = function () {
console.log(2)
}
Foo.prototype.getName = function () {
console.log(3)
}
// 在变量提升之后，此时5的函数会被4给替换，因为前面的getName在变量提升之后是5函数
var getName = function () {
console.log(4)
}
function getName() {
console.log(5)
}
// 请写出以下的输出结果
Foo.getName() // 2
getName() //4
// 这里的执行顺序是先执行Foo函数，也就是(Foo()).getName(),
// Foo执行后，函数中的getName没有变量修饰符，也就是会在全局变量中找，那么此时全局变量中的getName被1函数赋值了
// Foo返回了一个this值,this指向window,最后的变成window.getName(),此时getName是全局函数,因此会执行,输出1
Foo().getName() //1
// 此时getName已经被修改了
getName() //1
// new (Foo.getName)() ==> new (function(){console.log(2);})() 会执行该函数并产生一个实例对象
new Foo.getName() //2
// new Foo()是一个实例对象,此时类的原型对象上有一个getName函数,输出
new Foo().getName() //3
// new ((new Foo()).getName)() ==> new (function(){console.log(3);})() 执行该函数
new new Foo().getName() //3
function A() {
console.log(1)
}
function Fn() {
A = function () {
console.log(2)
}
return this
}
Fn.A = A
Fn.prototype = {
A: () => {
console.log(3)
},
}
A() //1
Fn.A() //1
Fn().A() //2
new Fn.A() //1
new Fn().A() //3
new new Fn().A() //报错,箭头函数不能new
}
function New (fn, ...args) {
// 创建一个空的对象并链接到构造函数的原型，使它能访问原型中的属性
const instance = object.create(fn.prototype)
// 使用apply改变构造函数中this的指向实现继承，使obj能访问到构造函数中的属性
const res = fn.apply(instance, args)
// 优先返回构造函数返回的对象
return typeof res === 'object' || typeof res === 'function' ? res : instance
}
function Person(name) {
this.name = name
}
Person.prototype.eat = function () {
console.log('Eatting')
}
var lindaidai = New(Person, 'LinDaiDai')
console.log(lindaidai, 'New') // Person{ name: 'LinDaiDai' }
lindaidai.eat() // 'Eatting'
手写call、apply、bind
Function.prototype.Call = function(context, ...args) {
if(!context) context = window
const f = Symbol()
context[f] = this
const res = context[f](...args)
delete context[f]
return res
}
Function.prototype.Apply = function(context, ...args) {
if(!context) context = window
const f = Symbol()
context[f] = this
const res = context[f](args)
delete context[f]
return res
}
Function.prototype.Bind= function(context, ...args) {
if(!context) context = window
const f = Symbol()
context[f] = this
return function(...args1) {
const res = context[f](...args, ...agrs1)
delete context[f]
return res
}
}
var obj = {
name: 'objName',
}
var name = 'globalName'
function consoleInfo(sex, weight) {
console.log(this.name, sex, weight, 'this指向 call apply bind')
}
consoleInfo('man', 100) // 'globalName' 'man' 100
consoleInfo.Call(obj, 'man', 100) // 'objName' 'man' 100
consoleInfo.Call(obj, 'woman', 120) // 'objName' 'woman' 120
consoleInfo.Apply(obj, ['man', 100]) // 'objName' 'man' 100
consoleInfo.Apply(obj, ['woman', 120]) // 'objName' 'woman' 120
consoleInfo.Bind(obj, 'man', 100)() // 'objName' 'man' 100
consoleInfo.Bind(obj, 'woman', 120)() // 'objName' 'woman' 120
相关题目
var a = 10
function foo() {
// 默认模式下 函数的this执行window
console.log(this.a) // 10
}
foo()
'use strict'
var a = 10
function foo() {
// 严格模式下 函数的this 指向 undefined
console.log('this1', this) // undefined
console.log(window.a) // 10
console.log(this.a) // 报错，undefined上没a
}
console.log(window.foo) // f foo(){...}
console.log('this2', this) // windiow
foo()
// let const 声明的变量不存在变量提升 window下无 a,b 变量
let a = 10
const b = 20
function foo() {
console.log(this.a) // undefined
console.log(this.b) // undefined
}
foo()
console.log(window.a) // undefined
// let const 声明的变量不存在变量提升 window下无 a,b 变量
let a = 10
const b = 20
function foo() {
console.log(this.a) // undefined
console.log(this.b) // undefined
}
foo()
console.log(window.a) // undefined
var a = 1
function foo() {
var a = 2
console.log(this) // window
console.log(this.a) // 1
}
foo()
var a = 1
function foo() {
var a = 2
function inner() {
// 默认模式下，函数的this指向widow
console.log(this.a) // 1
}
inner()
}
foo()
function foo() {
console.log(this.a)
}
var obj = { a: 1, foo }
var a = 2
foo() // 2 显示绑定，window调用，函数this默认指向window
obj.foo() // 1 隐式绑定，由obj调用foo，obj中存在a变量为1，谁调用指向谁
function foo() {
console.log(this.a)
}
var obj = { a: 1, foo }
var a = 2
var foo2 = obj.foo
obj.foo() //1 隐式绑定，由obj调用foo，obj中存在a变量为1，谁调用指向谁
foo2() // 2 显示绑定，window调用，函数this默认指向window
function foo() {
console.log(this.a)
}
var obj = { a: 1, foo }
var a = 2
var foo2 = obj.foo
var obj2 = { a: 3, foo2: obj.foo }
obj.foo() // 1
foo2() // 2
obj2.foo2() // 3
function foo() {
console.log(this.a)
}
function doFoo(fn) {
// doFoo 作用域下 fn = foo
console.log(this)
fn()
}
var obj = { a: 1, foo }
var a = 2
doFoo(obj.foo) // window 2 显式绑定
function foo() {
console.log(this.a)
}
function doFoo(fn) {
// doFoo 作用域下 fn = foo
console.log(this)
fn()
}
var obj = { a: 1, foo }
var a = 2
var obj2 = { a: 3, doFoo }
obj2.doFoo(obj.foo) // obj2 2 隐式绑定
'use strict'
function foo() {
console.log(this.a)
}
function doFoo(fn) {
console.log(this)
fn()
}
var obj = { a: 1, foo }
var a = 2
var obj2 = { a: 3, doFoo }
obj2.doFoo(obj.foo) // obj2 undefined 没有 a，严格模式下this指向undefined
function foo() {
console.log(this.a)
}
var obj = { a: 1 }
var a = 2
foo() // 2
foo.call(obj) // 1
foo.apply(obj) // 1
foo.bind(obj)() // 1
var obj1 = {
a: 1,
}
var obj2 = {
a: 2,
foo1: function () {
console.log(this.a)
},
foo2: function () {
setTimeout(function () {
console.log(this)
console.log(this.a)
}, 0)
},
}
var a = 3
obj2.foo1() // 2
obj2.foo2() // window 3
var obj1 = {
a: 1,
}
var obj2 = {
a: 2,
foo1: function () {
console.log(this.a)
},
foo2: function () {
setTimeout(
function () {
console.log(this)
console.log(this.a)
}.call(obj1),
0
)
},
}
var a = 3
obj2.foo1() // 2
obj2.foo2() // obj1 1
var obj1 = {
a: 1,
}
var obj2 = {
a: 2,
foo1: function () {
console.log(this.a)
},
foo2: function () {
function inner() {
console.log(this)
console.log(this.a)
}
inner()
},
}
var a = 3
obj2.foo1() // 2
obj2.foo2() // window 3
function foo() {
console.log(this.a)
}
var obj = { a: 1 }
var a = 2
foo() // 2
foo.call(obj) // 1
foo().call(obj) // 2, Cannot read property 'call' of undefined
function foo() {
console.log(this.a)
return function () {
console.log(this.a)
}
}
var obj = { a: 1 }
var a = 2
foo() // 2
foo.call(obj) // 1
foo().call(obj) // 2 1
function foo() {
console.log(this.a)
return function () {
console.log(this.a)
}
}
var obj = { a: 1 }
var a = 2
foo() // 2
foo.bind(obj)
foo().bind(obj) // 2
function foo() {
console.log(this.a)
return function () {
console.log(this.a)
}
}
var obj = { a: 1 }
var a = 2
foo.call(obj)() // 1 2
var obj = {
a: 'obj',
foo: function () {
console.log('foo:', this.a)
return function () {
console.log('inner:', this.a)
}
},
}
var a = 'window'
var obj2 = { a: 'obj2' }
obj.foo()() // 'foo:obj' 'inner:window'
obj.foo.call(obj2)() // 'foo:obj2' 'inner:window'
obj.foo().call(obj2) // foo:'obj' 'inner:obj2'
var obj = {
a: 1,
foo: function (b) {
b = b || this.a
return function (c) {
console.log(this.a + b + c)
}
},
}
var a = 2
var obj2 = { a: 3 }
obj.foo(a).call(obj2, 1) // 6 a = 3 b = 2 c = 1
obj.foo.call(obj2)(1) // 6 a = 2 b = 3 c = 1
function foo1() {
console.log(this.a)
}
var a = 1
var obj = {
a: 2,
}
var foo2 = function () {
foo1.call(obj)
}
foo2() // 2
foo2.call(window) // 2
function foo1(b) {
console.log(`${this.a} + ${b}`)
return this.a + b
}
var a = 1
var obj = {
a: 2,
}
var foo2 = function () {
return foo1.call(obj, ...arguments)
}
var num = foo2(3) // 2 + 3
console.log(num) // 5
function foo(item) {
console.log(item, this.a)
}
var obj = {
a: 'obj',
}
var a = 'window'
var arr = [1, 2, 3]
arr.forEach(foo, obj) // 1 "obj", 2 'obj' 3 'obj'
arr.map(foo, obj) // 1 'obj' 2 'obj' 3 'obj'
arr.filter(function (i) {
console.log(i, this.a) // 1 "obj" 2 "obj" 3 "obj"
return i > 2
}, obj)
function Person(name) {
this.name = name
}
var name = 'window'
var person1 = new Person('LinDaiDai')
console.log(person1.name) // 'LinDaiDai'
function Person(name) {
this.name = name
this.foo1 = function () {
console.log(this.name)
}
this.foo2 = function () {
return function () {
console.log(this.name)
}
}
}
var person1 = new Person('person1')
person1.foo1() // person1
person1.foo2()() // undefined
var name = 'window'
function Person(name) {
this.name = name
this.foo = function () {
console.log(this.name)
return function () {
console.log(this.name)
}
}
}
var person2 = {
name: 'person2',
foo: function () {
console.log(this.name)
return function () {
console.log(this.name)
}
},
}
var person1 = new Person('person1')
person1.foo()() // 'person1' window
person2.foo()() // 'person2' window
var name = 'window'
function Person(name) {
this.name = name
this.foo = function () {
console.log(this.name)
return function () {
console.log(this.name)
}
}
}
var person1 = new Person('person1')
var person2 = new Person('person2')
person1.foo.call(person2)() // 'person2' window
person1.foo().call(person2) // 'person1' 'person2'
var obj = {
name: 'obj',
foo1: () => {
console.log(this.name)
},
foo2: function () {
console.log(this.name)
return () => {
console.log(this.name)
}
},
}
var name = 'window'
obj.foo1() // window
obj.foo2()() // obj obj
var name = 'window'
var obj1 = {
name: 'obj1',
foo: function () {
console.log(this.name)
},
}
var obj2 = {
name: 'obj2',
foo: () => {
console.log(this.name)
},
}
obj1.foo() // obj1
obj2.foo() // window
var name = 'window'
var obj1 = {
name: 'obj1',
foo: function () {
console.log(this.name)
return function () {
console.log(this.name)
}
},
}
var obj2 = {
name: 'obj2',
foo: function () {
console.log(this.name)
return () => {
console.log(this.name)
}
},
}
var obj3 = {
name: 'obj3',
foo: () => {
console.log(this.name)
return function () {
console.log(this.name)
}
},
}
var obj4 = {
name: 'obj4',
foo: () => {
console.log(this.name)
return () => {
console.log(this.name)
}
},
}
obj1.foo()() // obj1 window
obj2.foo()() // obj2 obj2
obj3.foo()() // window window
obj4.foo()() // window window
var name = 'window'
function Person(name) {
this.name = name
this.foo1 = function () {
console.log(this.name)
}
this.foo2 = () => {
console.log(this.name)
}
}
var person2 = {
name: 'person2',
foo2: () => {
console.log(this.name)
},
}
var person1 = new Person('person1')
person1.foo1() // person1
person1.foo2() // person1
person2.foo2() // window
var name = 'window'
function Person(name) {
this.name = name
this.foo1 = function () {
console.log(this.name)
return function () {
console.log(this.name)
}
}
this.foo2 = function () {
console.log(this.name)
return () => {
console.log(this.name)
}
}
this.foo3 = () => {
console.log(this.name)
return function () {
console.log(this.name)
}
}
this.foo4 = () => {
console.log(this.name)
return () => {
console.log(this.name)
}
}
}
var person1 = new Person('person1')
person1.foo1()() // person1 window
person1.foo2()() // person1 person1
person1.foo3()() // person1 window
person1.foo4()() // person1 person1
var name = 'window'
var obj1 = {
name: 'obj1',
foo1: function () {
console.log(this.name)
return () => {
console.log(this.name)
}
},
foo2: () => {
console.log(this.name)
return function () {
console.log(this.name)
}
},
}
var obj2 = {
name: 'obj2',
}
obj1.foo1.call(obj2)() // obj2 obj2
obj1.foo1().call(obj2) // obj1 obj1
obj1.foo2.call(obj2)() // window window
obj1.foo2().call(obj2) // window obj2
var name = 'window'
var person1 = {
name: 'person1',
foo1: function () {
console.log(this.name)
},
foo2: () => console.log(this.name),
foo3: function () {
return function () {
console.log(this.name)
}
},
foo4: function () {
return () => {
console.log(this.name)
}
},
}
var person2 = { name: 'person2' }
person1.foo1() // person1
person1.foo1.call(person2) // preson2
person1.foo2() // window
person1.foo2.call(person2) // window
person1.foo3()() // window
person1.foo3.call(person2)() // window
person1.foo3().call(person2) // person2
person1.foo4()() // person1
person1.foo4.call(person2)() // person2
person1.foo4().call(person2) // person1
var name = 'window'
function Person(name) {
this.name = name
this.foo1 = function () {
console.log(this.name)
}
this.foo2 = () => console.log(this.name)
this.foo3 = function () {
return function () {
console.log(this.name)
}
}
this.foo4 = function () {
return () => {
console.log(this.name)
}
}
}
var person1 = new Person('person1')
var person2 = new Person('person2')
person1.foo1() // person1
person1.foo1.call(person2) // person2
person1.foo2() // person1
person1.foo2.call(person2) // person1
person1.foo3()() // winodw
person1.foo3.call(person2)() // window
person1.foo3().call(person2) // person2
person1.foo4()() // person1
person1.foo4.call(person2)() // person2
person1.foo4().call(person2) // person1
var name = 'window'
function Person(name) {
this.name = name
this.obj = {
name: 'obj',
foo1: function () {
return function () {
console.log(this.name)
}
},
foo2: function () {
return () => {
console.log(this.name)
}
},
}
}
var person1 = new Person('person1')
var person2 = new Person('person2')
person1.obj.foo1()() // window
person1.obj.foo1.call(person2)() // window
person1.obj.foo1().call(person2) // person2
person1.obj.foo2()() // obj
person1.obj.foo2.call(person2)() // person2
person1.obj.foo2().call(person2) // obj
function foo() {
console.log(this.a) // 2
}
var a = 2
;(function () {
'use strict'
foo() // 2, window调用
})()
// 原型链继承
// 缺点：引用类型属性会被所有的实例对象共用
function SuperClass() {
this.name = 'Super'
this.info = {
child: 'Sub',
}
}
function SubClass() {}
SubClass.prototype = new SuperClass()
const sub1 = new SubClass()
const sub2 = new SubClass()
sub1.name = 'sub1'
console.log(sub1.name, sub2.name, '原型链继承 普通类型属性') // sub1, Super
sub1.info.child = 'sub1'
console.log(sub1.info.child, sub2.info.child, '原型链继承 引用类型属性') // sub1， sub1
// 盗用构造函数继承
// 缺点：无法访问父函数的原型对象
function SuperClass() {
this.name = 'Super'
this.info = {
child: 'Sub',
}
}
function SubClass() {
SuperClass.call(this)
}
SuperClass.prototype.super = 'prototype'
const sub1 = new SubClass()
const sub2 = new SubClass()
sub1.name = 'sub1'
console.log(sub1.name, sub2.name, '盗用构造函数继承 普通类型属性') // sub1, Super
sub1.info.child = 'sub1'
console.log(sub1.info.child, sub2.info.child, '盗用构造函数继承 引用类型属性') // sub1， Sub
console.log(sub1.super, '盗用构造函数继承 访问父类的原型') // undefined
// 组合式继承
// 缺点：父函数会被执行两次
function SuperClass() {
this.name = 'Super'
this.info = {
child: 'Sub',
}
console.log('组合式继承 父类执行了')
}
function SubClass() {
SuperClass.call(this)
}
SubClass.prototype = new SuperClass()
SuperClass.prototype.super = 'prototype'
const sub1 = new SubClass()
const sub2 = new SubClass()
sub1.name = 'sub1'
console.log(sub1.name, sub2.name, '组合式继承 普通类型属性') // sub1, Super
sub1.info.child = 'sub1'
console.log(sub1.info.child, sub2.info.child, '组合式继承 引用类型属性') // sub1， Sub
console.log(sub1.super, '组合式继承 访问父类的原型') // prototype
// 原型式继承，原型链继承的封装，也是Object.crate()的实现
// 未解决原型链继承的缺点
function createObject(o) {
function F() {}
F.prototype = o
return new F()
}
// 寄生式继承
function SuperClass() {
this.name = 'Super'
this.info = {
child: 'Sub',
}
console.log('寄生式继承 父类执行了')
}
SuperClass.prototype.super = 'prototype'
const superClass = new SuperClass()
function createObject(obj) {
//通过原型方式创建新的对象
let o = inheritObject(obj)
// 在这可以添加自定义的属性和方法
// 子类属性
o.childName = 'childName'
return o
}
const sub1 = createObject(superClass)
const sub2 = createObject(superClass)
console.log(sub1.info.child, '寄生式继承 sub1.info.child before') // Sub
sub1.info.child = 'child'
console.log(sub1.info.child, '寄生式继承 sub1.info.child after') // child
console.log(sub2.info.child) // Sub
console.log(sub1.super, '寄生式继承 sub1.super') // prototype
console.log(sub1.childName, '寄生式继承 sub1 childName') // childName
// 寄生组合式继承
function SuperClass() {
this.name = 'Super'
this.info = {
child: 'Sub',
}
console.log('寄生组合式继承 父类执行了')
}
function SubClass() {
SuperClass.call(this)
}
SuperClass.prototype.super = 'prototype'
function inheritProtype(SubClass, SuperClass) {
let p = inheritObject(SuperClass.prototype)
SubClass.prototype = p
p.constructor = SubClass
}
inheritProtype(SubClass, SuperClass)
const sub1 = new SubClass()
const sub2 = new SubClass()
console.log(sub1.info.child, '寄生组合式继承 sub1.info.child before') // Sub
sub1.info.child = 'child'
console.log(sub1.info.child, '寄生组合式继承 sub1.info.child after') // child
console.log(sub2.info.child) // Sub
console.log(sub1.super, '寄生组合式继承 sub1.super') // prototype
ES6 类
1） Class 类可以看作是构造函数的语法糖
2） Class 类中定义的方法，都是定义在该构造函数的原型上
3）使用static关键字，作为静态方法（静态方法，只能通过类调用，实例不能调用）
4）extents 关键字实际是寄生组合继承
了避免与访问器属性冲突，在构造函数中使用了一个带有下划线前缀的私有属性_myProperty。这是一种常见的命名约定，用于表示该属性应该被视为私有的，以防止直接访问
function Foo() {
getName = function () {
console.log(1)
}
return this
}
// 静态方法
Foo.getName = function () {
console.log(2)
}
// 成员方法
Foo.prototype.getName = function () {
console.log(3)
}
// 函数提升优先级高于变量提升，且不会被同名变量声明时覆盖，但是会被同名变量赋值后覆盖
var getName = function () {
console.log(4)
}
function getName() {
console.log(5)
}
//请写出以下输出结果：
Foo.getName() // 2
getName() // 4
// Foo().getName(); // undefined is not a function
getName() // 4
new Foo.getName() // 2
new Foo().getName() // 3
new new Foo().getName() // 3
for…of 遍历获取的是对象的键值，for…in 获取的是对象的键名；
for… in 会遍历对象的整个原型链，性能非常差不推荐使用，而 for … of 只遍历当前对象不会遍历原型链；
对于数组的遍历，for…in 会返回数组中所有可枚举的属性(包括原型链上可枚举的属性)，for…of 只返回数组的下标对应的属性值；
手写Reduce
Array.prototype.Reduce = function(fn, initValue) {
if(typeof fn !== 'function') {
throw new TypeError(`${fn} is not a function`)
}
let pre, index
const arr = this.slice()
// 如果没有提供initValue，找到数组中的第一个存在的值作为pre，下一个元素的下标作为index
if(initValue === undefined) {
for(let i = 0; i < arr.length; i++) {
if(!arr.hasOwnProperty(i)) continue
pre = arr[i]
index = i + 1
break
}
} else {
// 如果提供了initValue时，则作为pre的初始值，index从0开始
pre = initValue
index = 0
}
for(let i = index; i < arr.length; i++) {
if(arr.hasOwnProperty(i)) {
// 函数接收4个参数 pre, cur, index, array
pre = fn.call(undefined, pre, arr[i], i, this)
}
}
return pre
}
console.log([, , , 1, 2, 3, 4].Reduce((pre, cur) => pre + cur)) // 10
手写Map
Array.prototype.Map = function(fn, context) {
if(typeof fn !== 'function') {
throw new TypeError(`${fn} is not a function`)
}
const arr = this.slice()
const list = new Array(arr.length)
for(let i = 0; i < arr.length; i++) {
if(arr.hasOwnProperty(i)) {
list[i] = fn.call(context, arr[i], i, this)
}
}
return list
}
console.log([1, 2, 3].Map((item) => item * 2)) // [2, 4, 6]
手写filter
Array.prototype.Filter = function(fn, context) {
if(typeof fn !== 'function') {
throw new TypeError(`${fn} is not a function`)
}
const list = []
for(let i = 0; i < this.length; i++) {
if(fn.call(context, this[i], i, this)) {
list.push(this[i])
}
}
return list
}
console.log([1, 2, 3, 4].Filter((item) => item > 2)) // [3, 4]
手写some
Array.prototype.Some = function(fn) {
if(typeof fn !== 'function') {
throw new TypeError(`${fn} is not a function`)
}
let result = false
for(let i = 0; i < this.length; i++) {
if(fn(this[i], i)) {
result = true
break
}
}
return result
}
console.log([1, 2, 3, 4].Some((item) => item > 6)) // false
console.log([1, 2, 3, 4].Some((item) => item > 2)) // true
手写Every
Array.prototype.Every= function(fn) {
if(typeof fn !== 'function') {
throw new TypeError(`${fn} is not a function`)
}
let result = false
let index = 0
for(let i = 0; i < this.length; i++) {
if(fn(this[i], i)) {
index++
if(index === this.length - 1) {
reslut = true
}
}
}
return result
}
console.log([1, 2, 3, 4].Every((item) => item > 4)) // false
console.log([1, 2, 3, 4].Every((item) => item > 0)) // true
Undefined Null Number String Boolean Object Symbol BigInt (后面两个ES6新增)
基础数据类型（存放在栈中）：Undefined Null Number String Boolean Symbol BigInt
引用数据类型（存放在堆中）：Object (对象、数组、函数)
isNaN 和 Number.isNaN
NaN 是一个特殊的警戒值，它表示非数字，并且它不等于自身
NaN !== NaN (true)
typeof NaN === 'number' (true)
isNaN 会将传入的值进行数字转换，任何不能进行数字转换的值都返回true
Number.isNaN 会判断传入的值是否是数字，判断为数字再判断是不是NaN,不进行数据转换
