理解JS的三座大山

js三座大山——原型及原型链 前言 js的三座大山(原型及原型链、作用域及闭包,异步执行机制及单线程),一直是前端学习和面试中常常遇到的话题,所以深入学习这一块的知识还是很有必要的,下面详细讲解一下我对这一块的理解,记录一下学习过程。这一节主要讲一下原型及原型链,js是面向对象编程,在es6提出class概念前是如何实现类及继承关系的呢,就是通过原型和原型链来实现的。 一、构造函数、实例、原型对象 通过一个例子来看一下这三者之... 阅读详情

如图所示,JS的三座大山:

  • 同步、异步
  • 作用域、闭包
  • 原型、原型链

1. 同步、异步

JavaScript执行机制,重点有两点:

  1. JavaScript是一门单线程语言
  2. Event Loop(事件循环)是JavaScript的执行机制

JS为什么是单线程

最初设计JS是用来在浏览器验证表单操控DOM元素的是一门脚本语言,如果js是多线程的,那么两个线程同时对一个DOM元素进行了相互冲突的操作,那么浏览器的解析器是无法执行的。

js为什么需要异步

如果js中不存在异步,只能自上而下执行,如果上一行解析时间很长,那么下面的代码就会被阻塞。

对于用户而言,阻塞就以为着“卡死”,这样就导致了很差的用户体验。比如在进行ajax请求的时候如果没有返回数据后面的代码就没办法执行

JS的事件循环(eventloop)是怎么运作的

  1. 首先判断JS是同步还是异步,同步就进入主线程运行,异步就进入event table.

  2. 异步任务在event table中注册事件,当满足触发条件后,(触发条件可能是延时也可能是ajax回调),被推入event queue

  3. 同步任务进入主线程后一直执行,直到主线程空闲时,才会去event queue中查看是否有可执行的异步任务,如果有就推入主线程中。

    如图所示:

    那怎么知道主线程执行栈为空呢?js引擎存在 monitoring process 进程,会持续不断的检查 主线程 执行栈 是否为空,一旦为空,就会去 event queue 那里检查是否有等待被调用的函数

    宏任务包含整个script代码块,setTimeout, setIntval

    微任务Promise , process.nextTick

    在划分宏任务、微任务的时候并没有提到async/ await的本质就是Promise

    setTimeout(function() {
     
        console.log('4')
    })
    
    new Promise(function(resolve) {
     
        console.log('1') // 同步任务
        resolve()
    }).then(function() {
     
        console.log('3')
    })
    console.log('2')
    执行结果: 1-2-3-4
    1. 这段代码作为宏任务,进入主线程。
    2. 先遇到setTimeout,那么将其回调函数注册后分发到宏任务event queue.
    3. 接下来遇到Promise, new Promise立即执行,then函数分发到微任务event queue
    4. 遇到console.log(), 立即执行
    5. 整体代码script作为第一个宏任务执行结束, 查看当前有没有可执行的微任务,执行then的回调。(第一轮事件循环结束了,我们开始第二轮循环)
    6. 从宏任务的event queue开始,我们发现了宏任务event queue中setTimeout对应的回调函数,立即执行。
    console.log('1')
    setTimeout(function() {
     
        console.log('2')
        process.nextTick(function() {
     
            console.log('3')
        })
        new Promise(function(resolve) {
     
            console.log('4')
            resolve()
        }).then(function() {
     
            console.log('5')
        })
    })
    
    process.nextTick(function() {
     
        console.log('6')
    })
    
    new Promise(function(resolve) {
     
        console.log('7')
        resolve()
    }).then(function() {
     
        console.log('8')
    })
    
    setTimeout(function() {
     
        console.log('9')
        process.nextTick(function() {
     
            console.log('10')
        })
        new Promise(function(resolve) {
     
            console.log('11')
            resolve()
        }).then(function() {
     
            console.log('12')
        })
    })
    1.整体script作为第一个宏任务进入主线程,遇到console.log(1)输出1
    
    遇到setTimeout, 其回调函数被分发到宏任务event queue中。我们暂且记为setTimeout1
    3.遇到process.nextTick(),其回调函数被分发到微任务event queue中,我们记为process1
    4.遇到Promise, new Promise直接执行,输出7.then被分发到微任务event queue中,我们记为then1
    又遇到setTimeout,其回调函数被分发到宏任务event queue中,我们记为setTimeout2.
    现在开始执行微任务, 我们发现了process1和then1两个微任务,执行process1,输出6,执行then1,输出8, 第一轮事件循环正式结束, 这一轮的结果输出1,7,6,8.那么第二轮事件循环从setTimeout1宏任务开始
    5. 首先输出2, 接下来遇到了process.nextTick(),统一被分发到微任务event queue,记为process2
    8new Promise立即执行,输出4,then也被分发到微任务event queue中,记为then2
    6. 现在开始执行微任务,我们发现有process2和then2两个微任务可以执行输出3,5. 第二轮事件循环结束,第二轮输出2,4,3,5. 第三轮事件循环从setTimeout2哄任务开始
    10。 直接输出9,跟第二轮事件循环类似,输出9,11,10,12
    7. 完整输出是1,7,6,8,2,4,3,5,9,11,10,12(请注意,node环境下的事件监听依赖libuv与前端环境不完全相同,输出顺序可能会有误差)

    async/await用来干什么

    用来优化promise的回调问题,被称为是异步的终极解决方案

    async/await内部做了什么

    async函数会返回一个Promise对象,如果在函数中return一个直接量(普通变量),async会把这个直接量通过Promise.resolve()封装成Promise对象。如果你返回了promise那就以你返回的promise为准。await是在等待,等待运行的结果也就是返回值。await后面通常是一个异步操作(promise),但是这不代表await后面只能跟异步才做,await后面实际是可以接普通函数调用或者直接量。

    async相当于 new Promise,await相当于then

    await的等待机制

    如果await后面跟的不是一个promise,那await后面表达式的运算结果就是它等到的东西,如果await后面跟的是一个promise对象,await它会’阻塞’后面的diamante,等着promise对象resolve,

    然后得到resolve的值作为await表达式的运算结果。但是此"阻塞"非彼“阻塞”,这就是await必须用在async函数中的原因。

    async函数调用不会造成"阻塞",它内部所有的“阻塞”都被封装在一个promise对象中异步执行(这里的阻塞理解成异步等待更合理)

    async/await在使用过程中有什么规定

    每个async方法都返回一个promise, await只能出现在async函数中

    async/await在什么场景使用

    单一的promise链并不能发现async/await的有事,但是如果需要处理由多个promise组成的then链的时候,优势就能体现出来了(Promise通过then链来解决多层回调的问题,现在又用async/awai来进一步优化它)

2. 作用域、闭包

闭包

  • 闭包是指有权访问另外一个函数作用域中的变量的函数(红宝书)
  • 闭包是指那些能够访问自由变量的函数。(MDN)其中自由变量, 指在函数中使用的,但既不是函数参数arguments也不是函数的局部变量的变量,其实就是另外一个函数作用域中的变量。)

作用域

  • 说起闭包,就必须要说说作用域,ES5种只存在两种作用域:
  1. 函数作用域。
  2. 全局作用域 当访问一个变量时,
    解释器会首先在当前作用域查找标示符,如果没有找到, 就去父作用域找, 直到找到该变量的标示符或者不在父作用域中,
  3. 这就是作用域链,每一个子函数都会拷贝上级的作用域, 形成一个作用域的链条。
let a = 1;

function f1() {
 
    var a = 2

  function f2() {
 
       var a = 3;
       console.log(a); //3
   }
}

在这段代码中,

  • f1的作用域指向有全局作用域(window) 和它本身,
  • 而f2的作用域指向全局作用域(window)、 f1和它本身。
  • 而且作用域是从最底层向上找, 直到找到全局作用域window为止,
  • 如果全局还没有的话就会报错。闭包产生的本质就是,
  • 当前环境中存在指向父级作用域的引用。
function f2() {
 
    var a = 2

    function f3() {
 
        console.log(a); //2
    }
    return f3;
}
var x = f2();
x();

这里x会拿到父级作用域中的变量, 输出2。

因为在当前环境中,含有对f3的引用, f3恰恰引用了window、 f3和f3的作用域。

因此f3可以访问到f2的作用域的变量。那是不是只有返回函数才算是产生了闭包呢?回到闭包的本质,只需要让父级作用域的引用存在即可。

var f4;

function f5() {
 
    var a = 2
    f4 = function () {
 
        console.log(a);
    }
}
f5();
f4();

让f5执行,给f4赋值后,等于说现在f4拥有了window、f5和f4本身这几个作用域的访问权,还是自底向上查找,最近是在f5中找到了a,因此输出2。在这里是外面的变量f4存在着父级作用域的引用,

因此产生了闭包,形式变了,本质没有改变。

场景

  • 返回一个函数。
  • 作为函数参数传递。
  • 在定时器、 事件监听、 Ajax请求、 跨窗口通信、 Web Workers或者任何异步中,只要使用了回调函数, 实际上就是在使用闭包。
    IIFE(立即执行函数表达式) 创建闭包, 保存了全局作用域window和当前函数的作用域。
var b = 1;
	function foo() {
 
	    var b = 2;
	
	    function baz() {
 
	        console.log(b);
	    }
	    bar(baz);
	}
	
	function bar(fn) {
 
	    // 这就是闭包
	    fn();
	}
	// 输出2,而不是1
	foo();
	// 以下的闭包保存的仅仅是window和当前作用域。
	// 定时器
	setTimeout(function timeHandler() {
 
	   console.log('111');
	}, 100)
	
	// 事件监听
	// document.body.click(function () {
 
	//     console.log('DOM Listener');
	// })
	
	// 立即执行函数
	var c = 2;
	(function IIFE() {
 
	    // 输出2
	    console.log(c);
	})();

经典的一道题

for (var i = 1; i <= 5; i++) {
 
    setTimeout(function timer() {
 
        console.log(i)
    }, 0)
}  // 6 6 6 6 6 6
// 为什么会全部输出6? 如何改进, 让它输出1, 2, 3, 4, 5?

解析:

  • 因为setTimeout为宏任务, 由于JS中单线程eventLoop机制, 在主线程同步任务执行完后才去执行宏任务。
  • 因此循环结束后setTimeout中的回调才依次执行, 但输出i的时候当前作用域没有。
    往上一级再找,发现了i,此时循环已经结束,i变成了6,因此会全部输出6。
    利用IIFE(立即执行函数表达式)当每次for循环时,把此时的i变量传递到定时器中
for (var i = 0; i < 5; i++) {
 
	    (function (j) {
 
	        setTimeout(() => {
 
	            console.log(j)
	        }, 1000);
	    })(i)
	}

给定时器传入第三个参数, 作为timer函数的第一个函数参数

for (var i = 0; i < 5; i++) {
 
	    setTimeout(function (j) {
 
	        console.log(j)
	    }, 1000, i);
	}

使用ES6中的let

  • let使JS发生革命性的变化, 让JS有函数作用域变为了块级作用域,
  • 用let后作用域链不复存在。 代码的作用域以块级为单位,
for (let i = 1; i <= 5; i++) {
 
    setTimeout(function timer() {
 
        console.log(i)
    }, 2000)
}

3.原型、原型链

原型(prototype)

JS中所有函数都会有prototype属性,只有函数才有

其所有的属性和方法都能被构造函数的实例对象共享访问

代码如下:

function Person(name){
 
		this.name = name
	}
	Person.prototype.sayHello(){
 
		console.log('sayHello')
	}
	let p1 = new Person();
	let p2 = new Person();
	console.log(p1.sayHello) //sayHello
	console.log(p2.sayHello) //sayHello

构造函数(constructor)

JS中constructor存在每个函数的prototype属性中,其保存了指向该函数的引用

Person.prototype.constructor ==Person   //true

原型链(_ _ proto _ _)

JS中对象都会有个内置属性,即__proto__,(隐式原型链的属性),一般情况下执行创建它的构造函数的prototype的属性,另外函数比较特殊,也会有该属性

p1.__proto__ == Person.prototype

JS 引擎查找摸个属性时,先查找对象本身是否存在该属性,如果不存在就会在原型链上一层一层进行查找

有几个面试经常会问的几个问题

如何精确地判断短数组的类型

[] instanceof Array   //[].__proto__ == Array.prototype

Object.prototype.toString.call([])  //[Object Array]

Array.isArray([]) //true

[].constructor ==Array

下面代码输出什么

Object instanceof Function //true
Function instanceof Object // true

实现一个原型链继承

function Person(name){
 
		this.name = name
	}
	Person.prototype.sayHello(){
 
		console.log('sayHello')
	}
	function Boy(){
 };
	Boy.prototype = new Person();
	let b1 = new Boy();
	b1.sayHello() //sayHello

原型、原型链、构造函数、实例的关系

1.instanceof检测构造函数与实例的关系:

function Person () {
 .........}
	
	person = new Person ()
	
	res = person instanceof Person
	
	res  // true

2.实例继承原型上的定义的属性:

function Person () {
 ........}
	
	Person.prototype.type = 'object n'
	
	person = new Person ()
	
	res = person.type
	
	res  // object n

3.实例访问 ===> 原型

实例通过__proto__访问到原型 person.proto=== Person.prototype

4.原型访问 ===> 构造函数

原型通过constructor属性访问构造函数 Person.prototype.constructor === Person

5.实例访问===>构造函数

person.proto.constructor === Person

二、原型链

在读取一个实例的属性的过程中,如果属性在该实例中没有找到,那么就会循着 proto 指定的原型上去寻找,如果还找不到,则寻找原型的原型:

  1. 实例上寻找
function Person() {
 }

    Person.prototype.type = "object name Person";

    person = new Person();

    person.type = "我是实例的自有属性";

    res = Reflect.ownKeys(person); //尝试获取到自有属性

    console.log(res);

    res = person.type;

    console.log(res); //我是实例的自有属性(通过原型链向上搜索优先搜索实例里的)
  1. 原型上寻找
function Person() {
 }

    Person.prototype.type = "object name Person";

    person = new Person();

    res = Reflect.ownKeys(person); //尝试获取到自有属性

    console.log(res);

    res = person.type;

    console.log(res); //object name Person
  1. 原型的原型上寻找
function Person() {
 }

    Person.prototype.type = "object name Person";

    function Child() {
 }

    Child.prototype = new Person();

    p = new Child();

    res = [p instanceof Object, p instanceof Person, p instanceof Child];

    console.log(res); //[true, true, true] p同时属于Object,Person, Child

    res = p.type; //层层搜索

    console.log(res); //object name Person (原型链上搜索)

    console.dir(Person);

    console.dir(Child);
  1. 原型链上搜索
  • 原型同样也可以通过 proto 访问到原型的原型,比方说这里有个构造函数 Child 然后“继承”前者的有一个构造函数 Person,然后 new Child 得到实例 p;

  • 当访问 p 中的一个非自有属性的时候,就会通过 proto 作为桥梁连接起来的一系列原型、原型的原型、原型的原型的原型直到 Object 构造函数为止;

  • 原型链搜索搜到 null 为止,搜不到那访问的这个属性就停止:

function Person() {
 }

  Person.prototype.type = "object name Person";

  function Child() {
 }

  Child.prototype = new Person();

  p = new Child();

  res = p.__proto__;

  console.log(res);         //Person {}

  res = p.__proto__.__proto__;

  console.log(res);         //Person {type:'object name Person'}

  res = p.__proto__.__proto__.__proto__;

  console.log(res);         //{.....}

  res = p.__proto__.__proto__.__proto__.__proto__;

  console.log(res);         //null

继承

  • JS 中一切皆对象(所有的数据类型都可以用对象来表示),必须有一种机制,把所有的对象联系起来,实现类似的“继承”机制。
  • 不同于大部分面向对象语言,ES6 之前并没有引入类(class)的概念,JS 并非通过类而是通过构造函数来创建实例,javascript中的继承是通过原型链来体现的。
  • 其基本思想是利用原型让一个引用类型继承另一个引用继承的属性和方法。

什么是继承

  • js中,继承是一种允许我们在已有类的基础上创建新类的机制;它可以使用现有类的所有功能,并在无需重新编写
  • 原来的类的情况下对这些功能进行扩展。

为什么要有继承

  • 提高代码的重用性、较少代码的冗余

目前我总结的一共有6种继承方式

  • 原型链继承,
  • 借用构造函数继承,
  • 组合式继承(原型链+构造函数),
  • 原型式继承,
  • 寄生式继承,
  • 寄生组合式继承
function Person(name){
 
	this.name = name;
	this.sum=function(){
 
		alert('this.name',this.name)
	}
}
Person.prototype.age = 100
  1. 原型链继承

    实现方式:利用原型链的特点继承,让实例的原型等于父类的实例

    优点:实例可以继承父类的构造个函数,实例的构造函数,父类的原型

    缺点:不能向父类传递参数,由于实例的原型等于父类的实例,那么改变父类的属性,实例的属性也会跟着改变

function child(){
 
	this.name="xiaoming"
}
child.prototype = new Person()
let child1 = new Child()
child1.name //xiaoming
child1.age //100
child1 instanceof Person //true
  1. 借用构造函数继承

    实现方式:使用call/apply将父类的构造函数引入子类函数

    优点:可以祢补原型链继承的缺点,可以向父类传递参数,只继承父类构造函数的属性

    缺点:不能复用,每次使用需要重新调用,每个实例都是父类构造函数的副本,比较臃肿

function child(){
 
		Person.call(this,'xiaoming')
	}
	let child1 = new child()
	child1.name //xiaoming
	child1.age //100
	child1 instanceof Person //false
  1. 组合式继承

    实现方式:复用+可传递参数

    优点:基于原型链的优点和借用构造函数的优点

    缺点:调用两遍父类函数

function child(){
 
		Person.call(this,'xiaoming')
	}
	child.prototype = new Person 
	let child1 = new child()
	child1.name //xiaoming
	child1.age //100
	child1 instanceof Person //true
	child instanceof Person //false
  1. 原型式继承

    实现方式:函数包装对象,返回对象的引用,这个函数就变成可以随时添加实例或者对象,Object.create()就是这个原理

    优点:复用一个对象用函数包装

    缺点:所有实例都继承在原型上面 无法复用

function child(obj){
 
		 function F(){
 }
		 F.prototype = obj
		 return new F()
	}
	let child1 = new Person()
	let child2 = child(child1)
	child2.age //100
  1. 寄生式继承

    实现方式:在原型式继承外面包了一个壳子

    优点:创建一个新对象

    缺点:没有用到实例 无法复用

function child(obj){
 
		 function F(){
 }
		 F.prototype = obj
		 return new F()
	}
	let child1 = new Person()
	function subObject(){
 
		let sub =child(child1)
		sub.name='xiaoming'
		return sub
	}
	let child2 = subObject(child1)
	typeof subObject //function
	typeof child2 //object
	child2.age //100
  1. 寄生组合式继承

    实现方式:在函数内返回对象的调用

    优点:函数的实例等于另外的一个实例,使用call/apply引入另一个构造函数,可传递参数,修复了组合继承的问题

    缺点:无法复用

function child(obj){
 
			 function F(){
 }
			 F.prototype = obj
			 return new F()
		}
		let child1 = child(Person.prototype)
		function Sub(){
 
			Person.call(this)
		}
		Sub.prototype = child
		child.constructor = Sub
		let sub1 = new Sub()
		sub1.age //100
【运动规划算法项目实战】全覆盖分区算法 全覆盖规划在机器人学领域具有重要意义,其应用场景涵盖了自动农场、扫地机器人、扫描监视无人机等多个领域。该问题的核心目标是使机器人能够从指定起点出发,规划一条避开障碍物、同时路径尽可能短的轨迹,从而实现对特定区域的全面覆盖。在实际应用中,全覆盖规划的成功实现对于提高机器人在各类环境中的工作效率至关重要。这一问题的解决涉及到高效的路径规划和规划区域分解技术。其中,梯形单元分解算法是一种常用分区的技术,过将地图上需要规划的区域进行分区,采用梯形分解的方式,可以更好地应对复杂环境。全覆盖算法规划流程。 阅读详情

相关推荐

ESP32基于Arduino环境开发128*160 TFT_LCD屏幕显示照片

ESP32基于Arduino环境开发128*160 TFT_LCD屏幕显示照片

weixin_42854045的博客 2059

javascript基础知识之三座大山

三座大山:1.原型  原型链                     2.作用域  闭包                     3.异步  单线程 后续补充

做自己 3687

中文文本纠错实战:pycorrector与kenlm的安装与高效使用指南

本文提供了一份详细的中文文本纠错实战指南,重点介绍了pycorrector与kenlm的安装与高效使用方法。内容涵盖从编译环境准备、依赖安装到核心参数调优、批量处理及领域自适应等全流程,旨在帮助开发者快速部署并优化纠错系统,提升中文文本处理的质量与效率。

weixin_29055699的博客 411

JavaScript 的三座大山

js 作为前端的中坚力量。那么 javascript 三座大山,你知道是哪些呢?

xxxzzzqqq_的博客 545

Dynamics 365 On-Premise Server v9.0部署体验

期盼已久的Dynamics 365 On-Premise的版本升级终于在11月初姗姗来迟。 11月2日起已经可以在官方渠道下载正式版的Dynamics 365 Server v9.0安装文件,版本号9.0.2,随手附上中文版安装文件下载地址。 想必已经有不少小伙伴开始尝试各种升级、安装了吧。 Dynamics 365 On-Premise的安装过程,度娘一下已经有很多了,这里就不赘述了,只是...

Roger的专栏 2140

AGI 之 【Dify】 之 Dify 在 Windows 端本地部署调用 Ollama 本地下载的大模型, API 形式 Python 调用 进行简单聊天接口测试

AGI,即通用人工智能(Artificial General Intelligence),是一种具备人类智能水平的人工智能系统。它不仅能够执行特定的任务,而且能够理解、学习和应用知识于广泛的问题解决中,具有较高的自主性和适应性。AGI的能力包括但不限于自我学习、自我改进、自我调整,并能在没有人为干预的情况下解决各种复杂问题。本节将介绍如何使用 Dify 平台调用 Ollama 部署的本地模型来创建一个聊天应用。通过 API 的方式发起聊天,可以让前端自由布置所需的聊天形式。

仙魁XAN 1万+

JS三座大山--同步异步、作用域闭包、原型原型链

转载文章:https://blog.youkuaiyun.com/qq_34574204/article/details/125883420

m0_63834711的博客 187

VS2022错误列表高效处理:从复制到Excel表格的完整指南

本文详细介绍了在Visual Studio 2022中高效处理错误列表的实用技巧,重点讲解了如何将错误信息一键复制并粘贴到Excel表格中。通过基础操作、自定义视图、筛选功能及常见问题解决方案,帮助开发者将杂乱的编译错误整理成清晰、可排序、可筛选的数据表,极大提升了团队协作、错误分析和项目管理的效率。

weixin_28837817的博客 362

JavaScript同步和异步个人理解

同步和异步产生的原因 归根到底,JavaScript是一门“单线程”语言,不可以另外开辟线程 js为何是单线程的?   JavaScript的单线程与它的用途有关。作为浏览器脚本语言,JavaScript的主要用途是为来实现用户与浏览器的交互。   这就决定了它只能是单线程的,否则会带来很复杂的同步问题,比如:假定有两个线程,一个线程在某个DOM节点上添加内容,另一个线程删除了这个节点,这时浏览器应该以哪个线程为准?   为了避免这种复杂性,从一诞生,JavaScript就是单线程了,这已经成这门语言的

qq_44707531的博客 279

Matlab激活失败?手把手教你解决License checkout failed问题(附详细截图)

本文针对Matlab激活后出现“License checkout failed”错误的常见问题,提供了详细的解决方案。核心在于精准定位并正确填写Windows系统用户名,而非计算机名或账户全名。文章通过分步截图和命令指引,手把手教你使用`whoami`命令获取正确信息,并重新运行激活程序,从根本上解决因用户名填写错误导致的许可检查失败问题。

weixin_29062823的博客 584

【C2000系列DSP的双向DC-DC电源】基于TMS320F28034的DC-DC项目开发流程

理解DC-DC 双向电源(基于 TMS320F28034)的开发流程,需要从功能拆解、开发步骤、验证 / 测试项

昔时扬尘处 324

JS三座大山之原型链

在JS中原型链的概念刚开始可能一直迷惑着大多数人,我也一样,不过花点时间仔细的梳理梳理,还是很容易理解的。本文就着重介绍一下原型链,如有不对之处,欢迎指正,共同探讨,共同进步。 在面试时,面试官可能会通过对象的创建方式来引出原型链相关的问题: 那么创建对象的方式主要有以下几种: 第一种: 字面量 var Obj1 = {name:”o1”}; var Obj2 = new Object(...

simeng-han的博客 9809

MediaPipe 教程:从安装到应用-全网最全

MediaPipe是Google推出的开源框架,专为构建机器学习管道设计,可以高效处理视频、音频等时间序列数据。本文教程从安装到应用逐步讲解: 安装步骤简单,只需通过pip安装mediapipe包并验证版本; 重点演示人体姿态检测功能,可识别33个身体关键点; 提供基础代码实现,包括视频捕获、关键点检测与可视化; 强调模块化开发,将功能封装成类以提高代码复用性。 教程适合初学者,通过清晰指引和实用代码示例,帮助快速实现计算机视觉应用。

FJN110的博客 1567

详细理解JS的三座大山

详细理解JS的三座大山

辉生活-记录程序生活的点滴。 1038

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

JS的三座大山之闭包(自己理解)

JS高级特性中闭包是一个特色。所谓闭包,本质就是在一个函数内部创建另一个函数。JS的百度解释: 闭包就是能够读取其他函数内部变量的函数。例如在javascript中,只有函数内部的子函数才能读取局部变量,所以闭包可以理解成“定义在一个函数内部的函数“。在本质上,闭包是将函数内部和函数外部连接起来的桥梁。 闭包的特性: ①函数嵌套函数(函数B嵌套在A的内部)(函数A返回函数B) ②函数内部可以引用函数外部的参数和变量(沿着作用域链寻找,先从自身开始查找,如果自身没有继续往上级查找,自身拥有直接调用,哪个近

大雪纷斐的博客 1151

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

JS的三座大山之原型和原型链(自己理解)

参考1 参考2 原型和原型链是JS高级特性中的另一个特色。 一、构造函数 构造函数 ,是一种特殊的方法。主要用来在创建对象时初始化对象, 即为对象成员变量赋初始值,总与new运算符一起使用在创建对象的语句中。特别的一个类可以有多个构造函数 ,可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载 构造函数和普通函数的创建都相同,不同的是习惯上构造函数首字母大写。另外就是调用方式不同,普通函数直接调用,构造函数需要使用new关键字来调用 function Person(name, ag

大雪纷斐的博客 1000

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

原型和原型链的理解_《带你翻越js三座大山》之原型&原型链

主要是讲一下ES6的原型和原型链。先抛出三个问题:如何准确判断一个变量是不是数组?根据原型和原型链仿写jq,要考虑插件和扩展性。class原型的本质是什么?怎么去理解?带着这三个问题,一步一步来深入了解并认识原型和原型链。三个知识点:class和集成类型判断instanceof原型和原型链1、class 包含constructor 属性 方法。 // 类 2、继承 ,extends super ...

weixin_39555579的博客 74

深入理解JavaScript的三座大山:同步异步,作用域与闭包,原型与原型链

JS的事件循环(eventloop)是怎么运作的 首先判断JS是同步还是异步,同步就进入主线程运行,异步就进入event table. 异步任务在event table中注册事件,当满足触发条件后,(触发条件可能是延时也可能是ajax回调),被推入event queue 同步任务进入主线程后一直执行,直到主线程空闲时,才会去event queue中查看是否有可执行的异步任务,如果有就推入主线程中。

zzzhhhy的博客 361

(五)JS基础知识二(通过图理解原型和原型链)【三座大山之一,必考!!!】

qwq

lj1530562965的博客 424

攻克JavaScript 的三座大山

基本语法:了解 JavaScript 的基本语法,包括变量声明、数据类型、运算符、条件语句、循环语句等。数据类型和类型转换:熟悉 JavaScript 的数据类型,包括原始数据类型(字符串、数字、布尔值、null、undefined)和复杂数据类型(对象、数组、函数等),以及类型转换的规则。函数:深入理解函数的定义、调用、参数传递和返回值,并掌握闭包、匿名函数和箭头函数等概念。对象和面向对象编程:了解 JavaScript 中的对象、原型和原型链,学习面向对象编程的基本思想和实现方式。

qq_66627105的博客 1899

js三座大山

#1、原型与原型链, #2、作用域及闭包, #3、异步和单线程, 原型与原型链 说到原型,就不得不提一下构造函数,首先我们看下面一个简单的例子: function Dog(name,age){ this.name = name; this.age = age; } let dog1 = new Dog("哈士奇",3); let dog2 = new Dog("泰迪",2);...

flykus的博客 2195

前端面试送命题-JS三座大山

前言本篇文章比较适合3年以上的前端工作者,JS三座大山分别指:原型与原型链,作用域及闭包,异步和单线程。原型与原型链说到原型,就不得不提一下构造函数,首先我们看下面一个简单的例子:function Dog(name,age){ this.name = name; this.age = age; } let dog1 = new Dog("哈士奇",3); let dog2 ...

li123128的博客 5155

JS三座大山 —— 原型和原型链

利用流程图带你全方面理解原型和原型链!构造函数通过prototype属性指向原型对象,原型对象包含了共享的属性和方法,而对象实例通过原型链(__proto__属性指向原型对象)继承了原型对象的属性和方法。通过属性,我们可以追溯到对象实例的构造函数。这些概念共同构成了 JavaScript 中的原型继承机制。

悟其浅而深修,沉其心而精进 2554

前端javascript总结笔记(一)--js的三座大山

前言: 第一章为变量类型和计算。 第二章到第四章分别是原型与原型链,作用域及闭包,异步和单线程,这三个就是我们说的三座大山。 一、变量类型和计算 1:JS中使用typeof能得到哪些类型? 字符串(String)、数值(Number)、布尔值(Boolean)、Undefined、[Null对象,数组(Array),函数(Function) ](Object)共5种 2:何时使用=...

单车去旅行的博客 2374

js三座大山----(第三座山)

JS三座大山再学习(三、异步和单线程) 前言 写这一篇的时候,BiKaBi查阅了很多资料和文章,但是相当多的文章写的都很简单,甚至互相之间有矛盾,这让我很困扰;同时也让我坚定了要写出一篇好的关于JS异步、单线程、事件循环的文章,下面,让我们一起来学习本文吧,冲鸭~~ 单线程 什么是单线程 //栗子1 console.log(1) console.log(2) console.log(3) /...

weixin_43932097的博客 1524

JS三座大山

JS三座大山 原型与原型链 (请看上一篇的博客) 第一座大山 原型与原型链 第二座大山 作用域及作用域链 作用域有三种: {全局作用域、函数作用域、块级作用域} 全局作用域:声明在window上的对象 var a=100; var声明的全局变量相当于 window.a=100; //第二种 console.log(b) var b=300 ----》结果是undefined b相当于全局变量,不赋值,则是undefined 函数作用域: //第一种 function f

confidence冯瑶的博客 296
上一篇: 【TypeScript】常见的设计模式
下一篇: Mybatis代理对象生成
JavaShark
博客等级 码龄4年 184粉丝 438原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值