精华内容
下载资源
问答
  • 相互独立事件理解

    千次阅读 2018-03-13 10:23:42
    【2013年下半年-初级中学、高级中学-简答题】射手向区间 [0,1]射击一...因为相交就意味着事件相互影响,互斥意味着事件不可能同时发生;而相互独立事件既有可能同时发生,也有可能不同时发生,那么它们到底是什么关...

    【2013年下半年-初级中学、高级中学-简答题】
    射手向区间 [0,1]射击一次,落点服从均匀分布。若射中 [0,1/2]区间,则观众甲中奖;若射中 [x,3/5]区间,则观众乙中奖。若甲中奖和乙中奖这两个事件独立,求 x的值。

    相互独立事件其实没有明确的相交与互斥关系。因为相交就意味着事件相互影响,互斥意味着事件不可能同时发生;而相互独立事件既有可能同时发生,也有可能不同时发生,那么它们到底是什么关系呢?其实这就是概率问题,可能同时发生,也有可能不同时发生,这和物理中的波粒二象性有些类似,如果一定要画图像,它们的图像就是动态的。


    相互独立事件之间没有相互的影响,故其中一个事件的发生不影响另一个事件的发生概率,则必然存在两个事件同时发生的可能性(除非有一个事件概率为0)。

    实际上,相互独立事件是有相交关系的事件间关系的特例。相互独立事件间必然有P(A I B)= P(A)及P(B I A)= P(B),关于这一点可以这么理解:P(A I B)是事件B发生后事件A发生的概率,通常的计算是P(AB)/P(B),实际意义是事件A和事件B同时发生的可能性在事件B发生(包含事件A同时发生的情况)的可能性中占的比率(即在事件B的范围内事件A的发生概率),由于A和B相互独立,事件B的发生不对事件A的发生造成影响,即在事件B的范围内事件A的发生概率和整个样本空间中事件A发生的概率一样,所以有P(A I B)= P(A)和 P(B I A)= P(B)。



    发生a和发生b没有任何关系,可能都发生,也可能都不发生,也可能只发生一个,就是相互独立事件


    展开全文
  • 事件轮询机制理解

    千次阅读 2019-08-23 17:01:38
    进程:cpu资源分配的最小的单位,是拥有资源和独立运行的最小单位,程序执行时,会创建一个进程,cpu为其分配资源,加入进程就绪队列。 线程:cpu调度的最小单位,是程序执行的最小单位。 进程与线程的关系:线程...

    进程与线程

    首先简单了解下进程和线程的概念

    • 进程:cpu资源分配的最小的单位,是拥有资源和独立运行的最小单位,程序执行时,会创建一个进程,cpu为其分配资源,并加入进程就绪队列。
    • 线程:cpu调度的最小单位,是程序执行的最小单位。

    进程与线程的关系:线程是在进程的基础上建立一次程序运行单位,一个进程可以有多个线程。进程相当于工厂,线程相当于工人,各进程间相互独立,同个进程中的线程共享其中的资源。

    浏览器是多进程的,浏览器的进程包括:

    • Browser进程 ,浏览器的主控线程,只有一个,负责浏览器界面显示,与用户交互,管理各个页签和其他进程网络资源。
    • 第三方插件进程 ,插件打开时创建一个进程。
    • GPU进程 ,最多一个,用于3D绘制。
    • 浏览器渲染进程(浏览器内核或Renderer进程) 一个页签打开就是一个进程,多个空白页签合并为一个进程。

    其中,浏览器渲染进程又有以下线程:

    • js引擎线程,js内核,解析处理JavaScript脚本,运行代码,一个页签只有一个。
    • 图形用户界面GUI渲染线程,用于解析HTML、css,构建DOM树和RenderObject树,布局,绘制。当界面需要重绘或者某种操作引发回流时执行。与js引擎线程互斥,在js引擎线程执行时GUI被挂起并保存到队列中,直到js引擎线程空闲时立即执行,防止渲染前后数据不一致,因此若js引擎执行时间过长,会导致页面渲染加载阻塞。
    • 事件触发线程,属于浏览器而不是js引擎,用于处理事件循环。当鼠标点击、异步请求或执行setTimeout的代码块时,将对应任务添加到事件线程中,等待js引擎空闲时处理。
    • 定时触发器线程,setInterval与setTimeout所在线程,用于计数,计数完成后将任务添加到事件触发线程中,因此记完数后并非立刻执行任务,这个数只是最小的延时时间,若js引擎未空闲需要继续等待。W3C在HTML标准中规定,规定要求setTimeout中低于4ms的时间间隔算为4ms。
    • 异步http请求线程 ,在XMLHTTPRequest连接后通过浏览器开一个线程请求,将检测到状态变更时,如果设置有回调函数,异步线程就产生状态变更事件,将这个回调再放入事件队列中。再由JavaScript引擎执行。

    对于非常耗时的工作会导致js执行过长时间而阻塞页面,可以使用Web Worker 向浏览器申请开一个子线程。

    Web Worker :在构造时接受一个JavaScript文件的url(包含要在worker中运行的代码),它运行在与当前windows不同的另一个全局上下文中,该线程属于浏览器,不操作dom,只负责计算。主线程与worker通过postMessage相互通信。

    前面铺垫这么多,是为了能更好地理解事件轮询机制。

    事件轮询

    事件轮询(Event Loop):一个程序结构,用来等待和发送消息和事件。由于JavaScript是单线程语言,用来协调事件(event),用户交互(user interaction),脚本(script),渲染(rendering),网络(networking)等。事件循环又分为两种,一种针对浏览上下文(browsing context),另一种针对worker(web worker)。

    • js的任务分为同步任务和异步任务,异步任务必须指定回调函数。主线程执行同步任务,只负责读取和执行,形成一个执行栈,事件触发线程则管理一个任务队列(也可以说消息队列)。
    • 当主线程的执行栈调用某些api,如鼠标点击、ajax请求、setTimeOut时,在各自线程处理完毕后才将事件添加到队列中。
    • 当执行栈执行完,会读取任务队列中最先的事件,并将对应的回调函数加入执行栈,执行完再去调取,如此反复。若队列的代码中存在其他异步任务,则不会排在当前的任务队列之后,属于另一个事件循环。

    图片来自详解事件循环与任务队列
    图源来自

    任务优先级

    一个事件循环是可以有多个任务队列的,每个任务都有一个任务源,相同任务源的任务只能在一个任务队列中,一个任务队列的执行顺序是先进先出,多个任务队列有优先级,但根据宿主环境的不同,优先级也不同,不能保证固定。

    es6标准中,任务又分为两种类型,宏任务(macrotask)和微任务(microtask)。

    • 宏任务:由宿主环境提供,比如setTimeout、setInterval、网络请求、用户I/O、script(整体代码)、UI rendering、setImmediate(node)。
    • 微任务:语言标准(ECMAScript)提供,如process.nextTick(node)、Promise、Object.observe、MutationObserver。

    在polyfill版本中Promise是通过setTimeout模拟实现的,则属于macrotask

    根据任务分类,又将任务队列分为宏观任务队列(microtask queue)和微观任务队列(microtask queue)。任务队列的读取顺序是先读取所有微观任务队列执行后再读取一个宏观任务队列,再读取所有微观任务队列,再读取一个宏观任务队列…

    图片来自详解事件循环与任务队列
    在这里插入图片描述

    参考文章:
    事件轮询(Event Loop)
    从浏览器多进程到JS单线程,JS运行机制最全面的一次梳理
    并发模型与事件循环
    JavaScript:彻底理解同步、异步和事件循环(Event Loop)
    详解事件循环与任务队列
    JavaScript 运行机制详解:再谈Event Loop
    什么是浏览器的事件循环(Event Loop)?

    展开全文
  • 1 FreeRTOS中事件理解 事件是一种实现任务间通信的机制,主要用于实现多任务间的同步,但事件通信只能是事件类型的通信,无数据传输。与信号量不同的是,它可以实现一对多,多对多的同步。即一个任务可以等待多个...

    1 FreeRTOS中事件的理解

    事件是一种实现任务间通信的机制,主要用于实现多任务间的同步,但事件通信只能是事件类型的通信,无数据传输。与信号量不同的是,它可以实现一对多,多对多的同步。即一个任务可以等待多个事件的发生:可以是任意一个事件发生时唤醒任务进行事件处理;也可以是几个事件都发生后才唤醒任务进行事件处理。同样,也可以是多个任务同步多个事件。

    2 事件的运作机制

    应用一个实例来解释,更加易懂。

    任务1对事件3或事件5感兴趣(逻辑或),当发生其中的某一个事件都会被唤醒,并且执行相应操作。而任务2对事件3与事件5感兴趣(逻辑与),当且仅当事件3与事件5都发生的时候,任务2才会被唤醒,如果只有一个其中一个事件发生,那么任务还是会继续等待事件发生。如果接在收事件函数中设置了清除事件位xClearOnExit,那么当任务唤醒后将把事件3和事件5的事件标志清零,否则事件标志将依然存在。

     

    3 编写事件主要步骤

    3.1 创建事件

    FreeRTOS给我们提供了一个创建事件的函数xEventGroupCreate(),当创建一个事件时,系统会首先给我们分配事件控制块的内存空间,然后对该事件控制块进行基本的初始化,创建成功返回事件句柄;创建失败返回NULL。所以,在使用创建函数之前,我们需要先定义有个事件的句柄。

     

    3.2 事件组置位

    xEventGroupSetBits()用于置位事件组中指定的位,当位被置位之后,阻塞在该位上的任务将会被解锁。使用该函数接口时,通过参数指定的事件标志来设定事件的标志位,然后遍历等待在事件对象上的事件等待列表,判断是否有任务的事件激活要求与当前事件对象标志值匹配,如果有,则唤醒该任务。简单来说,就是设置我们自己定义的事件标志位为1,并且看看有没有任务在等待这个事件,有的话就唤醒它。

    EventBits_t xEventGroupSetBits(   EventGroupHandle_t xEventGroup,

                                                                  const EventBits_t uxBitsToSet    );

    xEventGroup:事件句柄;

    uxBitsToSet:指定事件中的事件标志位。如设置uxBitsToSet0x08则只置位位3,如果设置uxBitsToSet0x09则位3和位0                                都需要被置位;

    返回值:   返回调用xEventGroupSetBits() 时事件组中的值。

     

    3.3 事件等待

    FreeRTOS提供了一个等待指定事件的函数——xEventGroupWaitBits(),通过这个函数,任务可以知道事件标志组中的哪些位,有什么事件发生了,然后通过 “逻辑与”、“逻辑或”等操作对感兴趣的事件进行获取,并且这个函数实现了等待超时机制,当且仅当任务等待的事件发生时,任务才能获取到事件信息。在这段时间中,如果事件一直没发生,该任务将保持阻塞状态以等待事件发生。EventGroupWaitBits()用于获取事件组中的一个或多个事件发生标志,当要读取的事件标志位没有被置位时任务将进入阻塞等待状态。

    EventBits_t xEventGroupWaitBits(     const EventGroupHandle_t xEventGroup,

                                                                      const EventBits_t uxBitsToWaitFor,

                                                                      const BaseType_t xClearOnExit,

                                                                      const BaseType_t xWaitForAllBits,

                                                                      TickType_t xTicksToWait    );

    xEventGroup:事件句柄;

    uxBitsToWaitFor:一个按位或的值,指定需要等待事件组中的哪些位置1。如果需要等待bit 0 and/or bit 2那么uxBitsToWaitFor  配置为0x05(0101b)。如果需要等待bits 0 and/or bit 1 and/or bit 2那么uxBitsToWaitFor配置为0x07(0111b);

    xClearOnExit:pdTRUE:当xEventGroupWaitBits()等待到满足任务唤醒的事件时,系统将清除由形参uxBitsToWaitFor指定的事件标志位;

    pdFALSE:不会清除由形参uxBitsToWaitFor指定的事件标志位;

    xWaitForAllBits:pdTRUE:当形参uxBitsToWaitFor指定的位都置位的时候,xEventGroupWaitBits()才满足任务唤醒的条件,这也是“逻辑与”等待事件,并且在没有超时的情况下返回对应的事件标志位的值;pdFALSE:当形参uxBitsToWaitFor指定的位有其中任意一个置位的时候,这也是常说的“逻辑或”等待事件,在没有超时的情况下函数返回对应的事件标志位的值;

    xTicksToWait:最大超时时间,单位为系统节拍周期,常量portTICK_PERIOD_MS用于辅助把时间转换成MS;

    返回值:   返回事件中的哪些事件标志位被置位,返回值很可能并不是用户指定的事件位,需要对返回值进行判断再处理。

     

    4 实验结果

    打印的显示截图如下:

    /***
    *****************************************************************************************
    主程序和各个任务程序,截取程序主要部分,各个文件的句柄放在头文件里面的,需要读者自己加入
    就行了,最好再声明一下任务函数,另外我发现程序转过来后注释全成了乱码,但是不影响程序运行
    *****************************************************************************************
    **
    */
    
    static void KEY_Task(void* parameter)
    {
    while(1)
        {
    			if(Key_Scan(KEY1_GPIO_PORT, KEY1_GPIO_PIN)==KEY_ON)
    			{
    			printf("KEY1±»°´ÏÂ\n");
    			xEventGroupSetBits( Event_Handle, KEY1_EVENT );
    			}
    			vTaskDelay(10);
        }
    }
    
    static void LED3_Task(void* parameter)
    {
       EventBits_t R_event;
    	while(1)
    	{
    		R_event= xEventGroupWaitBits( Event_Handle,
    		                                KEY1_EVENT,
    		                                 pdTRUE,
    	                                    pdTRUE,
    		                             portMAX_DELAY);
    		printf("½ÓÊܵ½Ê¼þKEY1_EVENT\n");
    		if(  R_event==KEY1_EVENT)
    		{
    		LED3_ON;
    		vTaskDelay(500);
    		LED3_OFF;
    		}
    	}
    }
    
    static void AppTaskCreate(void)
    {
    	BaseType_t xReturn=pdPASS;
    	
    	taskENTER_CRITICAL();  
    	 
    		Event_Handle=xEventGroupCreate();
    		 if(NULL!= Event_Handle)
    		 printf("Event_Handleʼþ´´½¨Íê³É\n");
    
        	xReturn  = xTaskCreate( (TaskFunction_t)KEY_Task,  
    					                  (const char*)"KEY_Task",              
    					                  (uint32_t)128 ,   
    					                  (void *) NULL,                 
                                      (UBaseType_t) 4,           
    					          (TaskHandle_t *) &KEY_Task_Handle);   
    					                  
        if(pdPASS==xReturn)
    	    printf ("KEY_Task founded successfully by bieber\n");
        else 
    	    printf("KEY_Task founded failed by biebier\n");
    
        	/* ½¨Á¢ÈÎÎñLED3_Task  */
        xReturn  = xTaskCreate( (TaskFunction_t)LED3_Task,  
    					                  (const char*)"LED3_Task",             
    					                  (uint32_t)128 ,  
    					                  (void *) NULL,              
                                         (UBaseType_t) 5,             
    					             (TaskHandle_t *)&LED3_Task_Handle);    
    					                  
        if(pdPASS==xReturn)
    	    printf ("LED3_Task founded successfully by bieber\n");
        else 
    	    printf("LED3_Task founded failed by biebier\n");		
    		
    	vTaskDelete(AppTaskCreate_Handle);   
    	
    		taskEXIT_CRITICAL();        					   
    }
    
    int main(void)
    
    {
      BaseType_t xReturn=pdPASS;  
      BSP_Init();   
    	printf(" ²âÊÔ³ÌÐò¿ªÊ¼ \n");
    
     xReturn = xTaskCreate( (TaskFunction_t) AppTaskCreate, 
    					                  (const char *)"APPTaskCreate",             
    					                  (uint32_t)512 ,  
    					                  (void *) NULL,           
                                          (UBaseType_t) 1,            
    					                  (TaskHandle_t *)&AppTaskCreate_Handle); 
      if(pdPASS== xReturn)
    	  vTaskStartScheduler();     
    	else
    		return -1;
      while(1);
    
    }
    

     

     

     

    展开全文
  • 事件冒泡原理自我理解以及使用

    千次阅读 2017-06-24 15:00:30
    1.事件冒泡,就是元素自身的事件被触发后,如果父元素有相同的事件,如onclick事件,那么元素本身的触发状态就会传递,也就是冒到父元素,父元素的相同事件也会一级一级根据嵌套关系向外触发,直到document/window,...

    首先,这是我自己在学习过程中对于时间冒泡原理的理解,如果有不对的地方,读者尽可提出,不断学习。

    一:事件冒泡和阻止冒泡以及使用场景:

    1.事件冒泡,就是元素自身的事件被触发后,如果父元素有相同的事件,如onclick事件,那么元素本身的触发状态就会传递,也就是冒到父元素,父元素的相同事件也会一级一级根据嵌套关系向外触发,直到document/window,冒泡过程结束。

    2.比如:

    <div class="box" styel="width:200px; height: 200px;background_color:'#ddd'">

    <div class="box1" styel="width:200px; height: 200px;background_color:'#000'>

    <div class="box2" styel="width:200px; height: 200px;background_color:'#eee'></div>

    </div>

    </div>

    <script>

    document.querySelector(".box").οnclick=function(){

    alert("我是box")

    }

    document.querySelector(".box1").οnclick=function(){

    alert("我是box1")

    }

    document.querySelector(".box2").οnclick=function(){

    alert("我是box2")

    }

    document.οnclick=function(){

    alert("我是document")

    }

    </script>

    此时触发box2中的额onclick事件,会依次弹出“我是box2” 我是box1 我是box1 我是document。这就是事件冒泡。

    3.但是事件冒泡在某些应用场景产生一些问题,就是我们不需要触发的事件,由于冒泡的原因,也会运行。所以在这个时候要取消事件冒泡。直接粘图(不知道用什么工具直接粘贴代码,带原格式的。。。)

        box.onmouseover = function (event) {
            // 阻止冒泡
            event = event || window.event;
            if(event && event.stopPropagation){
                event.stopPropagation();
            }else{
                event.cancelBubble = true;
            }
        }

    4.那么事件冒泡和组织冒泡什么时候会用到呢?

    记着只要是能够触发事件冒泡的情况下,就考虑取消事件冒泡,或者直接利用事件冒泡。

    在这里,有一个例子,可以实现阻止事件冒泡来实现,就是模态框的显示和隐藏:(模态框不懂自行参考)。

        <div class="mask">
            <div class="login" id="login"></div>
        </div>
        <a href="#">注册</a>
        <a href="#">登陆</a>
        <script>
            //1.给登录绑定事件
            var mask = document.getElementsByClassName("mask")[0];
            var a = document.getElementsByTagName("a")[1];
            a.onclick = function (event) {
                //显示模态框
                 ele.style.display = "block";
                //阻止冒泡
                event = event || window.event;
                if(event && event.stopPropagation){
                    event.stopPropagation();
                }else{
                    event.cancelBubble = true;
                }
            }
            //2.给document绑定事件,因为可以冒泡,只要判断,点击的不是login,那么隐藏模态框
               document.onclick = function (event) {
                // 获取点击按钮后传递过来的值。
                event = event || window.event;
                //兼容获取事件触动时,被传递过来的对象
               var aaa = event.target || event.srcElement;
                var aaa = event.target?event.target:event.srcElement;
                console.log(event.target);
                //判断目标值的ID是否等于login,如果等于不隐藏盒子,否则隐藏盒子。
                if(aaa.id !== "login"){
                    mask.style.display = "none";
                }
                alert("123")
            }
        </script>

    解释:因为document和a都绑定了onclick事件,而且是嵌套的关系,当点击a标签的时候,会造成事件冒泡,既会显示mask模态框,又会弹出“123”的弹出框,所以我们要组织事件的冒泡。如上。

    然后判断点击的对象target是不是mask,如果不是mask,就运行mask.style.display="none",模态框消失。

    二:事件委托:

    1.刚开始接触事件委托概念的时候,很是懵逼,搞不懂到底是一个怎样的委托过程,怎么实现的,但是学到一定程度回过头来,也感觉很好理解。

    个人认为事件冒泡存在的意义,就是在事件运行过程中,避免使用循环遍历的方式去给每个同级元素触发相同的事件,而优化性能。要知道,元素量无限大,循环遍历是个噩梦,这也是网站性能优化的一个方面,就是尽量减少使用循环遍历。好了,简单说说我对事件委托理解,实例是摘抄过来的:

    如果要实现列表中,当鼠标over的时候,给每个li添加背景:一般想到的方法就是循环遍历添加,如下:

    <ul id="ul">
    	<li>aaaaaaaa</li>
    	<li>bbbbbbbb</li>
    	<li>cccccccc</li>
    </ul>
    window.onload = function(){
    	var oUl = document.getElementById("ul");
    	var aLi = oUl.getElementsByTagName("li");
    
    	for(var i=0; i<aLi.length; i++){
    		aLi[i].onmouseover = function(){
    			this.style.background = "red";
    		}
    		aLi[i].onmouseout = function(){
    			this.style.background = "";
    		}
    	}
    }
    在元素个数不多的情况下可以使用,但元素很多的时候,不建议使用,建议使用冒泡的事件委托:原理如下:

    window.onload = function(){
    	var oUl = document.getElementById("ul");
    	var aLi = oUl.getElementsByTagName("li");
    
    /*
    这里要用到事件源:event 对象,事件源,不管在哪个事件中,只要你操作的那个元素就是事件源。
    ie:window.event.srcElement
    标准下:event.target
    nodeName:找到元素的标签名
    */
    	oUl.onmouseover = function(ev){
    		var ev = ev || window.event;
    		var target = ev.target || ev.srcElement;
    		//alert(target.innerHTML);
    		if(target.nodeName.toLowerCase() == "li"){
    		target.style.background = "red";
    		}
    	}
    	oUl.onmouseout = function(ev){
    		var ev = ev || window.event;
    		var target = ev.target || ev.srcElement;
    		//alert(target.innerHTML);
    		if(target.nodeName.toLowerCase() == "li"){
    		target.style.background = "";
    		}
    	}
    }
    只要判断over或者out的对象,nodeName是不是"li",是的话就添加或者去掉背景。

    2.还有一种情况:就是新添加的元素:

    我们通常会使用Document.createElement("li");创建新的元素,然后再appendChild添加到父标签中。但是有这样一种情况,我是循环遍历给每个li标签绑定了鼠标悬停现实背景色的事件,但这样,新添加的元素就不会被循环到,因为添加之前已经循环停止了:所以:使用事件委托,就很好的解决了这个问题:

    window.onload = function(){
    	var oUl = document.getElementById("ul");
    	var aLi = oUl.getElementsByTagName("li");
    	var oBtn = document.getElementById("btn");
    	var iNow = 4;
    
    	oUl.onmouseover = function(ev){
    		var ev = ev || window.event;
    		var target = ev.target || ev.srcElement;
    		//alert(target.innerHTML);
    		if(target.nodeName.toLowerCase() == "li"){
    		target.style.background = "red";
    		}
    	}
    	oUl.onmouseout = function(ev){
    		var ev = ev || window.event;
    		var target = ev.target || ev.srcElement;
    		//alert(target.innerHTML);
    		if(target.nodeName.toLowerCase() == "li"){
    		target.style.background = "";
    		}
    	}
    	oBtn.onclick = function(){
    		iNow ++;
    		var oLi = document.createElement("li");
    		oLi.innerHTML = 1111 *iNow;
    		oUl.appendChild(oLi);
    	}
    }


    展开全文
  • 理解事件捕获和事件冒泡

    千次阅读 2016-04-03 17:28:09
    一年前刚开始接触JavaScript的时候就看过有关事件冒泡和事件捕获的文章,但是当时只是看过了就是看过了,没有自己实际的实践,没有什么自己的理解在里面,属于转眼就忘的那种状态,这段时间由于参加百度的ife前端...
  • C#委托,事件理解入门

    2011-06-01 16:00:08
    C#委托,事件理解入门 C#委托,事件理解入门 C#委托,事件理解入门 C#委托,事件理解入门 C#委托,事件理解入门 C#委托,事件理解入门 C#委托,事件理解入门 C#委托,事件理解入门 C#委托,事件理解入门 C#委托,事件理解入门 ...
  • 事件委托原理理解

    千次阅读 2017-12-15 09:50:27
    事件委托也叫事件代理, 定义:利用事件冒泡,只指定一个事件处理程序,就可以管理某一类型的所有事件 为什么要事件委托: 在JavaScript中,添加到页面上的事件处理程序数量将直接关系到页面的整体运行性能,因为...
  • 深入理解JavaScript事件冒泡

    千次阅读 2016-05-27 14:29:20
    在一个对象上触发某类事件(比如单击onclick事件),如果此对象定义了此事件的处理程序,那么此事件就会调用这个处理程序,如果没有定义此事件处理程序或者事件返回true,那么这个事件会向这个对象的父级对象传播,...
  • js事件处理机制的理解

    千次阅读 2017-07-11 10:16:27
    1、js事件机制 js中事件的发生包括捕获和冒泡两个阶段,两个阶段的传播顺序为 捕获:从最外边父元素节点传递至发生事件的元素节点,即由外到内; 冒泡:从发生事件的元素节点传递至最外边父元素节点,即由内到外...
  • UCos-II事件理解

    千次阅读 2018-07-29 01:56:26
    事件在使用前需要先创建,而创建事件要用到事件控制块,这个事件控制块存储事件的信息。 可以看出,创建事件本质上就是对这个结构体进行初始化。先来逐个弄清楚个成员所代表的意义, INT8U OSEventType:代表事件...
  • C#事件理解以及自定义事件的方法 事件理解:  在skyline项目的开发中,遇到了一个新的知识:事件。  在程序中,我希望实现一个功能,当视点坐标移动的时候可以实时的得到视点的坐标。 这里就需要使用...
  • bpmn事件

    万次阅读 2020-07-06 13:27:10
    本文章主要讲解bpmn事件,系列文章包含工作流、工作流系统、工作流引擎的相关讲解,涉及的到Camunda BPM、BPMN规范、activit的基础性知识,对于流程自动化、业务流程等进行了深入研究探讨。
  • STM32的"异常“、“中断”和“事件”区别和理解

    千次阅读 多人点赞 2018-01-18 11:34:35
    1 异常与中断(Cortex-M3)1.1 异常与中断原话: Cortex‐M3 在内核水平上搭载了一个异常响应... 所有能打断正常执行流的事件都称为异常。异常的概念包含中断的概念,即中断是异常的子集。异常与中断都是硬件支持的
  • 事件冒泡(快速理解

    千次阅读 2020-11-23 15:28:18
    event.currentTarget:指绑定了事件监听的元素(触发事件元素的父级元素) 这时判断两者相等,则执行相应的处理函数;当事件冒泡到上一级时,event.currentTarget变成 了上一级元素,这时候判断二者不相等,则就不...
  • Vue事件修饰符的理解

    千次阅读 2021-11-20 15:44:03
    Vue中的事件修饰符: 1.prevent:阻止默认事件(常用); 2.stop:阻止事件冒泡(常用); 3.once:事件只触发一次(常用); 4.capture:使用事件的捕获模式; 5.self:只有event.target是当前操作的元素时才触发...
  • thinkphp6 事件理解

    千次阅读 2020-03-19 16:15:39
    事件就是把一些要做的事封装起来,哪里要用就去调用这个事件 事件类不用生成也能触发(event); 事件监听:事件监听是一个一个生成的,一个事件监听负责一件事 事件订阅:事件订阅,一个类里面可以定义多个事件...
  • 彻底理解View事件体系!

    千次阅读 多人点赞 2016-06-27 14:18:02
    View的事件体系整体上理解还是比较简单的,但是却有很多细节。这些细节很容易忘记,本文的目标是理解性的记忆,争取做到看完不忘。最近在复习,希望本文能对你也有所帮助。如果你已经对View事件体系有一定的了解,...
  • 完全理解android事件分发机制

    千次阅读 2017-01-12 10:04:06
    前言之前笔者其实已经写过事件分发机制的文章:快速理解android事件传递拦截机制概念 但是,现在看来其实更像是一篇知识概括,多处可能未讲清楚,于是打算重写事件分发,用一篇文章大致讲清楚。 首先,形式上笔者...
  • 但是由于离散数学上的“贡献计数法”确实牛逼得很,无法超越,于是改讲概率论的多事件的加法公式。 网上找的,我就分析四个事件a,b,c,d的情况,然后给出一般规律。一般概率这东西,可以和集合的文氏图联系起来,...
  • 其实我一直准备写一篇关于Android事件分发机制的文章,从我的第一篇博客开始,就零零散散在好多地方使用到了Android事件分发的知识。也有好多朋友问过我各种问题,比如:onTouch和onTouchEvent有什么区别,又该如何...
  • window的load事件理解

    万次阅读 2018-07-25 11:22:31
    $(document).ready()在网页所有DOM结构绘制完毕后就执行,可能DOM元素关联的东西没有加载完,但网页的所有元素对jQuery是可以访问的,等价于DOMContentLoaded $(document).load() 需要注意一点,使用$...
  • 互斥 相互独立 两两独立 相互独立 的理解 最近好多朋友问我关于这些概念的,说比较模糊搞不懂 我就集中班门弄斧一下下了哈,集中回答一些问题,希望能对您有些帮助 埋坑,突然有事,先TODO一下吧快捷键 加粗 Ctrl + B ...
  • 数据库中事件理解总结

    千次阅读 2017-09-07 15:39:51
    在项目中经常要使用事件来处理一些历史数据,现在对数据库事件进行一个总结 事件简介 事件(event)是MySQL在相应的时刻调用的过程式数据库对象。一个事件可调用一次,也可周期性的启动,它由一个特定的线程来...
  • 在前写过“浅谈C#中的委托”和“浅谈C#中的事件”两篇博客,内容有些抽象,似乎难以说明委托和事件的...在.xmal中加入四个按钮,添加Window_Loaded事件。 代码如下:<Window x:Class="TestDelegateAndEvent.Main
  • 深入理解JavaScript的事件循环(Event Loop) 一、什么是事件循环 JS的代码执行是基于一种事件循环的机制,之所以称作事件循环,MDN给出的解释为因为它经常被用于类似如下的方式来实现 while (queue....
  • TP6手册理解之架构·事件

    万次阅读 2021-08-22 23:32:51
    官方定义: 新版的事件系统可以看成是5.1版本行为系统的升级版,事件系统相比行为系统强大的地方在于事件本身可以是一个类,并且可以更好的支持事件订阅者。 事件相比较中间件的优势是事件比中间件更加精准定位...
  • STM32中断触发和事件触发彻底理解

    千次阅读 多人点赞 2020-07-12 21:15:39
    先拿一件生活中的事情打比方对上述三个概念做个基本的粗略理解,之后再分享一个STM32 GPIO外部中断配置案例。 比如一老师在教室里给学生们上课。课堂上的学生可能做出各种行为动作,比方做笔记、打哈气、翻书包、讲...
  • js的事件理解

    千次阅读 2016-03-05 17:19:32
    事件捕获和事件冒泡事件流描述的是从页面中接收事件的顺序,也可理解事件在页面中传播的顺序。 事件流主要分为两种,即事件捕获和事件冒泡,这二者接受事件处理的顺序不同。假设下面的代码: <div id="inner">...
  • 事件对象:事件发生后,在flex中就称为事件对象,事件对象有针对其的侦听器,事件对象有其属性,比如:target。 事件发生的对象:指事件源。 事件源:发生事件的对象,一般指某一具体的组件,比如:...
  • 深入理解Solidity——事件(Events)

    千次阅读 2018-05-20 23:37:50
    事件(Events) 事件是使用EVM日志内置...这些日志与合约的地址关联,合并到区块链中,只要区块可以访问就一直存在。日志和事件在合约内不可直接被访问,即使是创建日志的合约。 日志的简单支付验证(SPV)是可能...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 698,050
精华内容 279,220
关键字:

并事件怎么理解