《仔仔细细分析Ext》 Ext对Function类的扩展

最新推荐文章于 2024-07-09 14:56:12 发布
最新推荐文章于 2024-07-09 14:56:12 发布
阅读量196 收藏
点赞数
分类专栏： ExtJs专题（学习） 文章标签： EXT prototype 编程 Spring 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wocaonimade123321/article/details/83496555
版权

原生 Function 类：

         参考手册并没有过多介绍 JS 内建的 Function 对象，只是介绍了如何用 new Function(name,arg…); 这样的方法来创建一个新的函数。

另外，通过其它资料我们还可以了解到，每个被定义的 function 都有 length 属性，它描述这个 function 定义时的实际参数个数。另一个属性就是原型： prototype ，当一个 function 被调用的时候， js 引擎负责创建 function 的 prototype 属性。

有可能内建的 Function 类本身没有什么其它实际可用的属性或方法；另一种可能是 js 不想暴露关于 Function 类的过多细节。因为如果这样做可能带来过度的复杂性。

 

Ext 对 Function 的扩展

         Ext 为 Function 扩展了五个实例方法： createCallback() 、 createDelegate() 、 defer() 、 createSequence() 、 createInterceptor() 。

         也就是说，在使用 Ext 框架时，对于每个自定义的函数，都可以直接调用这些方法。

         下面来看源码（注释都已翻译成中文）。

Js代码 复制代码
  1. <SPAN style="FONT-SIZE: medium">/**  
  2.     * @ Function类  
  3.     *这些方法对于每个Function对象都有效（任何一个js函数）。  
  4.     */  
  5. Ext.apply(Function.prototype, {   
  6.     /*该方法用来创建一个可以传递参数的回调函数。  
  7. *该方法可以直接在任何一个function上调用。  
  8. *例如：<code>myFunction.createCallback(arg1, arg2)</code>，这样就创建了一个绑定了  
  9. *两个参数的方法。  
  10.     *如果回调函数需要特定的作用域，请用createDelegate()方法替代。  
  11.     *createCallback()方法返回的函数总是在window作用域（顶级作用域）中执行。  
  12. *如果你想给一个回调方法传递参数，则需要使用该方法。如果不需要参数，你可以直  
  13. *接简单地传递一个函数的引用给需要回调的地方就可以了(例如callback: myFn)。（译者*注：这句话的意思就是说，如果你不需要向回调函数传递参数，就没有必要使用*createCallback()这个方法，直接按照常规的方式写就可以了）。  
  14. *然而，（译者注：按照常规的写法的话），如果你尝试向回调函数传递参数，(例如callback: *myFn(arg1, arg2))。那么函数在解析的时候就会被简单地执行。（译者注：而不是你期  
  15. *望的在发生某件事情之后再来回调。）  
  16.     *createCallback()的示例用法如下：  
  17.     <pre><code>  
  18. var sayHi = function(name){  
  19.     alert('Hi, ' + name);  
  20. }  
  21.  
  22. // clicking the button alerts "Hi, Fred"  
  23. new Ext.Button({  
  24.     text: 'Say Hi',  
  25.     renderTo: Ext.getBody(),  
  26.     handler: sayHi.createCallback('Fred')  
  27. });  
  28. </code></pre>  
  29.      *@返回值 {Function} 新的回调函数。  
  30.      */  
  31. createCallback : function(/*args...*/){   
  32. //使得传递进来的参数在下面的function中可用。（译者注：这里实际上是返回了//一个闭包函数，然后使用window来调用原来的函数，并把需要的参数传递进去。）   
  33.         var args = arguments;   
  34.         var method = this;   
  35.         return function() {   
  36.             return method.apply(window, args);   
  37.         };   
  38.     },   
  39.   
  40. /*创建一个代理（回调）函数，把作用域设置到参数obj上。  
  41.     *该函数可以直接再任何函数上调用。例如：<code>this.myFunction.createDelegate(this, *[arg1, arg2])</code>，这将创建一函数并自动把作用域设置到obj上，这样的话，新的*callback函数中的this属性指向obj对象。  
  42.     *用法示例：  
  43.     * <pre><code>  
  44. var sayHi = function(name){  
  45. //注意这里的this.text用法。这个函数期望在一个包含text属性的作用域中//执行。在这个例子中，这个’this’属性指向了下面传入createDelegate方法//的btn对象。  
  46.     alert('Hi, ' + name + '. You clicked the "' + this.text + '" button.');  
  47. }  
  48.  
  49. var btn = new Ext.Button({  
  50.     text: 'Say Hi',  
  51.     renderTo: Ext.getBody()  
  52. });  
  53.  
  54. //回调函数将在button实例的作用域中执行。  
  55. //点击按钮，将弹出"Hi, Fred. You clicked the ‘Say Hi’ button."  
  56.  
  57. btn.on('click', sayHi.createDelegate(btn, ['Fred']));  
  58. </code></pre>  
  59. * @参数1 {Object} obj (可选) 需要设置的目标作用域对象。  
  60.       * @参数2 {Array} args (可选) 覆盖默认的调用参数。(默认为调用者传递进来的参数。)  
  61.       * @参数3 {Boolean/Number} appendArgs (可选) 如果为true，（第二个参数）args被  
  62. *添加到调用参数中而不是覆盖。如果为数字，（第二个参数）args将被插入到指定的*位置。  
  63.      * @返回值 {Function} 新的函数  
  64.      */  
  65.     createDelegate : function(obj, args, appendArgs){   
  66.         var method = this;   
  67.         return function() {   
  68.             var callArgs = args || arguments;   
  69.             if(appendArgs === true){   
  70.                 callArgs = Array.prototype.slice.call(arguments, 0);   
  71.                 callArgs = callArgs.concat(args);   
  72.             }else if(typeof appendArgs == "number"){   
  73.                 callArgs = Array.prototype.slice.call(arguments, 0); // copy arguments first   
  74.                 var applyArgs = [appendArgs, 0].concat(args); // create method call params   
  75.                 Array.prototype.splice.apply(callArgs, applyArgs); // splice them in   
  76.             }   
  77.             return method.apply(obj || window, callArgs);   
  78.         };   
  79.     },   
  80.   
  81.      /*在指定的毫秒数之后调用函数，同时可以指定特定的作用域。  
  82.       *用法示例：  
  83.       * <pre><code>  
  84. var sayHi = function(name){  
  85.     alert('Hi, ' + name);  
  86. }  
  87.  
  88. // 立即执行:  
  89. sayHi('Fred');  
  90.  
  91. //2秒后执行:  
  92. sayHi.defer(2000, this, ['Fred']);  
  93.  
  94. //有时候这种语法在推迟执行一个匿名的函数的时候非常有用：  
  95. (function(){  
  96.     alert('Anonymous');  
  97. }).defer(100);  
  98. </code></pre>  
  99.      * @参数1 {Number} millis 设置调用setTimeout的毫秒数（如果为0函数立即被调用）。  
  100.      * @参数2 {Object} obj (可选) 需要设置的特定作用域  
  101.      * @参数2 {Array} args (可选) 覆盖默认的调用参数。(默认为调用者传递进来的参数。)  
  102.      * @参数3 {Boolean/Number} appendArgs (可选) 如果为true，（第二个参数）args被  
  103. * 添加到调用参数中而不是覆盖。如果为数字，（第二个参数）args将被插入到指定的* 位置。  
  104.      * @返回值 {Number} 定时器id，可以用来清除定时器。  
  105.      */  
  106.     defer : function(millis, obj, args, appendArgs){   
  107.         var fn = this.createDelegate(obj, args, appendArgs);   
  108.         if(millis){   
  109.             return setTimeout(fn, millis);   
  110.         }   
  111.         fn();   
  112.         return 0;   
  113.     },   
  114.   
  115.     /*使用原始的函数和传递进来的函数来创建一个组合的函数调用顺序（译者注：这是一*种类似管道式的调用效果，使用第一个函数的参数来调用第二个函数）。  
  116.     *最终执行的函数返回原始函数的结果。  
  117.     *使用原始函数的参数来调用传递进来的函数。  
  118.     *示例用法：  
  119.     * <pre><code>  
  120. var sayHi = function(name){  
  121.     alert('Hi, ' + name);  
  122. }  
  123.  
  124. sayHi('Fred'); //弹出 "Hi, Fred"  
  125.  
  126. var sayGoodbye = sayHi.createSequence(function(name){  
  127.     alert('Bye, ' + name);  
  128. });  
  129.  
  130. sayGoodbye('Fred'); //两个alert都会弹出  
  131. </code></pre>  
  132.      * @参数1 {Function} fcn 需要顺序执行的函数  
  133.  *@参数2 {Object} scope (optional) 传递进来函数的作用域 (默认作用域为原始函数的*作用域或window)  
  134.      * @返回值 {Function}  新的函数  
  135. */  
  136.     createSequence : function(fcn, scope){   
  137.         if(typeof fcn != "function"){   
  138.             return this;   
  139.         }   
  140.         var method = this;   
  141.         return function() {   
  142.             var retval = method.apply(this || window, arguments);   
  143.             fcn.apply(scope || this || window, arguments);   
  144.             return retval;   
  145.         };   
  146.     },   
  147.   
  148.        
  149. /*创建一个拦截函数。传入的函数在原始的函数之前执行。如果传入的函数返回false，*就不执行原始的函数。最终函数返回原始函数的执行结果。传递进来的函数使用原始*函数的参数来调用。  
  150.      *用法示例：  
  151.      * <pre><code>  
  152. var sayHi = function(name){  
  153.     alert('Hi, ' + name);  
  154. }  
  155.  
  156. sayHi('Fred'); // 弹出 "Hi, Fred"  
  157.  
  158. //创建一个新的函数来校验输入，而不直接去修改原始函数。  
  159. var sayHiToFriend = sayHi.createInterceptor(function(name){  
  160.     return name == 'Brian';  
  161. });  
  162.  
  163. sayHiToFriend('Fred');   //没有弹出  
  164. sayHiToFriend('Brian');  // 弹出"Hi, Brian"  
  165. </code></pre>  
  166.      * @参数1 {Function} fcn 需要在原始函数调用之前被调用的函数  
  167.      *@参数2 {Object} scope (可选) 拦截器的作用域(默认为原始函数的作用域或者window)  
  168.      * @返回值 {Function} 新的函数  
  169.      */  
  170.     createInterceptor : function(fcn, scope){   
  171.         if(typeof fcn != "function"){   
  172.             return this;   
  173.         }   
  174.         var method = this;   
  175.         return function() {   
  176.             fcn.target = this;   
  177.             fcn.method = method;   
  178.             if(fcn.apply(scope || this || window, arguments) === false){   
  179.                 return;   
  180.             }   
  181.             return method.apply(this || window, arguments);   
  182.         };   
  183.     }   
  184. });   
  185.   
  186. </SPAN>  
/**
 	* @ Function类
	*这些方法对于每个Function对象都有效（任何一个js函数）。
 	*/
Ext.apply(Function.prototype, {
	/*该方法用来创建一个可以传递参数的回调函数。
*该方法可以直接在任何一个function上调用。
*例如：<code>myFunction.createCallback(arg1, arg2)</code>，这样就创建了一个绑定了
*两个参数的方法。
	*如果回调函数需要特定的作用域，请用createDelegate()方法替代。
	*createCallback()方法返回的函数总是在window作用域（顶级作用域）中执行。
*如果你想给一个回调方法传递参数，则需要使用该方法。如果不需要参数，你可以直
*接简单地传递一个函数的引用给需要回调的地方就可以了(例如callback: myFn)。（译者*注：这句话的意思就是说，如果你不需要向回调函数传递参数，就没有必要使用*createCallback()这个方法，直接按照常规的方式写就可以了）。
*然而，（译者注：按照常规的写法的话），如果你尝试向回调函数传递参数，(例如callback: *myFn(arg1, arg2))。那么函数在解析的时候就会被简单地执行。（译者注：而不是你期
*望的在发生某件事情之后再来回调。）
	*createCallback()的示例用法如下：
	<pre><code>
var sayHi = function(name){
    alert('Hi, ' + name);
}

// clicking the button alerts "Hi, Fred"
new Ext.Button({
    text: 'Say Hi',
    renderTo: Ext.getBody(),
    handler: sayHi.createCallback('Fred')
});
</code></pre>
     *@返回值 {Function} 新的回调函数。
     */
createCallback : function(/*args...*/){
//使得传递进来的参数在下面的function中可用。（译者注：这里实际上是返回了//一个闭包函数，然后使用window来调用原来的函数，并把需要的参数传递进去。）
        var args = arguments;
        var method = this;
        return function() {
            return method.apply(window, args);
        };
    },

/*创建一个代理（回调）函数，把作用域设置到参数obj上。
	*该函数可以直接再任何函数上调用。例如：<code>this.myFunction.createDelegate(this, *[arg1, arg2])</code>，这将创建一函数并自动把作用域设置到obj上，这样的话，新的*callback函数中的this属性指向obj对象。
	*用法示例：
	* <pre><code>
var sayHi = function(name){
//注意这里的this.text用法。这个函数期望在一个包含text属性的作用域中//执行。在这个例子中，这个’this’属性指向了下面传入createDelegate方法//的btn对象。
    alert('Hi, ' + name + '. You clicked the "' + this.text + '" button.');
}

var btn = new Ext.Button({
    text: 'Say Hi',
    renderTo: Ext.getBody()
});

//回调函数将在button实例的作用域中执行。
//点击按钮，将弹出"Hi, Fred. You clicked the ‘Say Hi’ button."

btn.on('click', sayHi.createDelegate(btn, ['Fred']));
</code></pre>
* @参数1 {Object} obj (可选) 需要设置的目标作用域对象。
      * @参数2 {Array} args (可选) 覆盖默认的调用参数。(默认为调用者传递进来的参数。)
      * @参数3 {Boolean/Number} appendArgs (可选) 如果为true，（第二个参数）args被
*添加到调用参数中而不是覆盖。如果为数字，（第二个参数）args将被插入到指定的*位置。
     * @返回值 {Function} 新的函数
     */
    createDelegate : function(obj, args, appendArgs){
        var method = this;
        return function() {
            var callArgs = args || arguments;
            if(appendArgs === true){
                callArgs = Array.prototype.slice.call(arguments, 0);
                callArgs = callArgs.concat(args);
            }else if(typeof appendArgs == "number"){
                callArgs = Array.prototype.slice.call(arguments, 0); // copy arguments first
                var applyArgs = [appendArgs, 0].concat(args); // create method call params
                Array.prototype.splice.apply(callArgs, applyArgs); // splice them in
            }
            return method.apply(obj || window, callArgs);
        };
    },

	 /*在指定的毫秒数之后调用函数，同时可以指定特定的作用域。
	  *用法示例：
	  * <pre><code>
var sayHi = function(name){
    alert('Hi, ' + name);
}

// 立即执行:
sayHi('Fred');

//2秒后执行:
sayHi.defer(2000, this, ['Fred']);

//有时候这种语法在推迟执行一个匿名的函数的时候非常有用：
(function(){
    alert('Anonymous');
}).defer(100);
</code></pre>
   	 * @参数1 {Number} millis 设置调用setTimeout的毫秒数（如果为0函数立即被调用）。
     * @参数2 {Object} obj (可选) 需要设置的特定作用域
     * @参数2 {Array} args (可选) 覆盖默认的调用参数。(默认为调用者传递进来的参数。)
     * @参数3 {Boolean/Number} appendArgs (可选) 如果为true，（第二个参数）args被
* 添加到调用参数中而不是覆盖。如果为数字，（第二个参数）args将被插入到指定的* 位置。
     * @返回值 {Number} 定时器id，可以用来清除定时器。
     */
    defer : function(millis, obj, args, appendArgs){
        var fn = this.createDelegate(obj, args, appendArgs);
        if(millis){
            return setTimeout(fn, millis);
        }
        fn();
        return 0;
    },

	/*使用原始的函数和传递进来的函数来创建一个组合的函数调用顺序（译者注：这是一*种类似管道式的调用效果，使用第一个函数的参数来调用第二个函数）。
	*最终执行的函数返回原始函数的结果。
	*使用原始函数的参数来调用传递进来的函数。
	*示例用法：
	* <pre><code>
var sayHi = function(name){
    alert('Hi, ' + name);
}

sayHi('Fred'); //弹出 "Hi, Fred"

var sayGoodbye = sayHi.createSequence(function(name){
    alert('Bye, ' + name);
});

sayGoodbye('Fred'); //两个alert都会弹出
</code></pre>
     * @参数1 {Function} fcn 需要顺序执行的函数
 *@参数2 {Object} scope (optional) 传递进来函数的作用域 (默认作用域为原始函数的*作用域或window)
     * @返回值 {Function}  新的函数
*/
    createSequence : function(fcn, scope){
        if(typeof fcn != "function"){
            return this;
        }
        var method = this;
        return function() {
            var retval = method.apply(this || window, arguments);
            fcn.apply(scope || this || window, arguments);
            return retval;
        };
    },

    
/*创建一个拦截函数。传入的函数在原始的函数之前执行。如果传入的函数返回false，*就不执行原始的函数。最终函数返回原始函数的执行结果。传递进来的函数使用原始*函数的参数来调用。
	 *用法示例：
	 * <pre><code>
var sayHi = function(name){
    alert('Hi, ' + name);
}

sayHi('Fred'); // 弹出 "Hi, Fred"

//创建一个新的函数来校验输入，而不直接去修改原始函数。
var sayHiToFriend = sayHi.createInterceptor(function(name){
    return name == 'Brian';
});

sayHiToFriend('Fred');   //没有弹出
sayHiToFriend('Brian');  // 弹出"Hi, Brian"
</code></pre>
     * @参数1 {Function} fcn 需要在原始函数调用之前被调用的函数
     *@参数2 {Object} scope (可选) 拦截器的作用域(默认为原始函数的作用域或者window)
     * @返回值 {Function} 新的函数
     */
    createInterceptor : function(fcn, scope){
        if(typeof fcn != "function"){
            return this;
        }
        var method = this;
        return function() {
            fcn.target = this;
            fcn.method = method;
            if(fcn.apply(scope || this || window, arguments) === false){
                return;
            }
            return method.apply(this || window, arguments);
        };
    }
});

 


总结 :

         从以上的源码分析可以看出，对原生 Function 类的扩展全部使用了闭包。里面模拟了高级语言里面才有的代理、拦截器 。知道 Java 里面 Spring 的人对这里的代理模式 应该不陌生，知道 Struts2 的人应该很熟悉拦截器 的概念，后面还有模板 (XTemplate) ，相信 C++ 的 fans 读到的时候肯定会很兴奋。一点小小的感慨：对于编程，编程的思想和算法 是可以超越语言、甚至超越所谓的架构而存在的。如果我们能够把这些模式、这些思想烂熟于胸，使用起来收放自如，又何必去在乎何种语言，何必去争论所谓的 C/S 还是 B/S ？

         我相信，通过仔细阅读 Ext 的源代码，必定能对那些耳熟能详的所谓模式和思想有更进一层的体会。

         Ext 对原生对象的扩展到这里结束。

（今天早上找了一个 Easy CHM ，想把翻译的这些东西压缩成帮助文档，结果搞出来样子非常丑，希望哪位善于制作 CHM 的高手能给我一点帮助，能达到以下这种效果就成了，Ext提供的HTML式的效果就是这样的。这个图片是网上流传比较多的一份 Ext2.0 的 CHM 文档，没有翻译，好多东西还有错误在里面，后期有时间我想来尝试一遍阅读 2.2 的源码一边翻译这份 API 。练练 E 文，也算帮助一下他人 ^_^ ）。


         如你觉得自己 E 文还行，愿意提供帮助，可加 qun ： 88403922 参与

wocaonimade123321
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
百变鹏仔缤纷彩色文字广告位代码美化版
06-15
想给网站添加一个类似文字广告的菜单分类引导，就在其他网上看到这种虚线边框划过变色文字广告样式，感觉还是很不错的，仿照写一份分享给大家吧！ PC端时代码为8个文字块一行，H5为4个文字代码一行，所以大家添加...
浅析Ext为Function扩展的五个方法
脉兜
04-27 586
今天有兴趣查看了Ext的源码，就来浅析下Ext为Function扩展的五个方法吧！ 首先来分析下[b]createInterceptor[/b]，api是这么说的“创建一个拦截器函数，当该拦截器函数返回true时则执行原函数，否则不执行。”，首先看下它到源码： [code="js"]createInterceptor : function(fcn, scope){ ...
页面仔和他的小创新
03-04
这个职位在国外更多被称作WebDesigner，而我们更喜欢叫自己“页面仔”。如果你做过页面相关的编码工作，HTML、CSS、JavaScript应该是再了解不过的技术了。当然如果知识面再广一些，你可能还会接触如HTML5、CSS3等...
宏仔杂货商城小店网站
03-23
...1，导入数据库—数据库.sql ...3，上传源码到网站根目录 ...9，修改手机短信验证码接口AppSecret文件路径/Mao/function.php(第164行)申请地址：...(短信验证码申请成功后联系接口客服添加短信模板如下：) ...
GBA图书仔2 0.9版
04-08
5. **兼容性与移植性**：GBA图书仔2 0.9版需要确保生成的电子书能在各种GBA硬件上正常运行，这涉及对不同GBA模拟器和真实硬件的兼容性测试。 6. **性能优化**：为了在低性能的GBA设备上流畅运行，软件需要进行性能...
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
qq_43671872的博客
07-08 718
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
算法力扣刷题 三十一【150. 逆波兰表达式求值】
danaaaa的博客
07-04 693
后缀表示法。
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 289
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
每周算法：无向图的双连通分量
少儿编程乔老师
07-06 1229
通过Tarjan算法求无向连通图的双连通分量，计算至少添加多少条边可以将原图变为一个双连通分量。
秋招力扣刷题——从前序与中序遍历序列构造二叉树
qq_50604294的博客
07-04 242
给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。：两种代码的结束条件以及分割的右区间处理方式不同，后者更容易理解一点。
【算法笔记自学】第 5 章 入门篇（3）——数学问题
qq_62704693的博客
07-06 556
【代码】【算法笔记自学】入门篇（3）——数学问题。
算法力扣刷题 三十二【239. 滑动窗口最大值】
danaaaa的博客
07-05 670
单调队列（自定义一种队列规则）使用场景1.
算法库应用--Brute - Force算法串匹配(顺序串)
qq_57484399的博客
07-06 894
V1.0: 在原有的博客基础上, 加入我构建的算法库, 让博客更完全 , 代码可以运行看效果, 不是让算法仅仅停留在 逻辑方面, 这也是后续我努力的方向, 把这些算法模型, 尽可能的去运用到实际的嵌入式项目中, 把理论变成实物 , 本次也进行了名字优化, 让逻辑更清晰。利用B-f算法,寻找子串在母串中的位置。
二分查找算法【折半查找算法】
weixin_64534587的博客
07-09 537
二分查找法是一种在有序数组中查找特定元素的高效算法。它的工作原理是通过不断地将可能存在的范围，直至找到目标值或确定目标值不存在于数组中。二分查找的关键在于比较都能，因此其为，其中 n 是数组的长度。
【CT】LeetCode手撕—232. 用栈实现队列
weixin_44382896的博客
07-04 482
【代码】【CT】LeetCode手撕—232. 用栈实现队列。
【代码随想录算法训练营第五十九天|卡码网110.字符串接龙、105.有向图的完全可达性、106.岛屿的周长】
weixin_46281930的博客
07-05 446
这题是在字符串上进行广搜，字符串广搜是对一个字符串按照位置来搜索，与原字符串只有一个位置字符不同那么就是在原字符串的基础上距离加1。因此需要一个字典来记录每个字符串和beginStr的距离，然后创建一个队列，每次对队列第一个字符串进行广搜，找到匹配且没有访问过的字符串就加入队列尾部等待处理，并且在字典中令他的距离变成现在访问的字符串的距离+1，直到遇见和endStr匹配的字符串输出距离。DFS去从1开始深度搜索，搜索到的结点标注，最后如果所有结点都标注了就输出1否则为-1。
【代码随想录算法训练营第六十二天|卡码网53.寻宝（prim算法和kruskal算法）】
最新发布
weixin_46281930的博客
07-09 361
kruskal算法以边为导向，先把边按照长度从小到大排序，然后一个个检查边的两个端点是否在同一个集合中（这里使用并查集判断），在同一个集合中就不加入这个边，不在的话就加入。可以把所有已经使用过的结点看作一个整体，然后把他们相接的结点的结点顶点边中进行选择，选择最短的一条边把该结点入树，某种程度来说也是一种贪心？1.选择当前最短入树结点；3.更新结点距离最小生成树的距离。
二分查找2
qq_45965652的博客
07-06 1019
二分查找问题总结2。
二分法查找有序表的通用算法（可查链表，数组，字符串...等等）
weixin_42944928的博客
07-04 294
find_binary函数find_binary函数。
服装网络营销策划方案.doc
07-13
"此文档是一个关于服装行业的网络营销策划方案，涵盖了行业背景分析、竞争情况、企业网站现状、网络营销推广策略及效果评价。" 1. 行业背景分析：全球范围内，牛仔服装因其休闲、舒适、耐用的特点深受消费者喜爱，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值