JavaScript高级特征之面向对象笔记

Javascript面向对象
函数:
        * Arguments对象:
            * Arguments对象是数组对象
            * Arguments对象的length属性可以获取参数的个数
            * 利用Arguments对象模拟函数的重载效果(javascript中不存在函数重载)


        * 变量的作用域:
            * 全局变量与局部变量
                * 全局变量:全局域与函数域(局部域)
                * 局部变量:当前函数域

 


            * 全局域与函数域
            * 定义局部变量时,不使用"var",局部变量变成全局变量

 


            * 定义全局变量与局部变量同名时,函数域中只能访问局部变量


        * 几种特殊函数:
            * 匿名函数:没有名的函数

javascript可以将函数作为数据使用。作为函数本体,它像普通的数据一样,不一定要有名字。默认名字的函数被称之为“匿名函数”。例如:
function (a){return a;}
匿名函数的两种用法:
可以将匿名函数作为参数传递给其他函数。这样,接收方函数就能利用所传递的函数来完成某些事情。
可以定义某个匿名函数来执行某些一次性任务
            * 回调函数:把一个函数作为参数传递给另一个函数,而作为参数的函数叫做回调函数

 1 function add(a, b){
 2     return a() + b();
 3 }
 4 var one = function(){return 1;}
 5 var two = function(){return 2;}
 6 alert(add(one,two));        //output    3
 7     
 8 //可以直接使用匿名函数来替代one()和two(),以作为目标函数的参数
 9 alert(add(function(){return 1;}, function(){return 2;}));
10 在这个例子中,函数one和two都是回调函数。
11 当将函数A传递给函数B,并由B来执行A时,A就成了一个回调函数(callback function)。如果A还是一个无名函数,就称之为匿名回调函数。
12 回调函数的优点:
13 它可以在不做命名的情况下传递函数(这意味着可以节省全局变量)。
14 可以将一个函数调用操作委托给另一个函数(这意味着可以节省一些代码编写工作)。
15 回调函数也有助于提升性能。(重要)
16 下面的代码,利用回调函数如何优化?
17     //该函数通过一个循环将其所接收的三个参数分别乘以2,并以数组的形式返回结果
18     function two(a, b, c){
19         var i, arr = [];
20         for(i = 0;i < 3; i++){
21             arr[i] = arguments[i] * 2;
22         }
23         return arr;
24     }
25     
26     //将接收的参数加一后返回
27     function addone(a){
28         return a + 1;
29     }
30     
31     //测试上面的两个函数
32     alert(two(1, 2, 3));    //output    [2, 4, 6]
33     alert(addone(100));    //output    101
34     
35     //将三个数据在两个函数之间传递
36     var myarr = [];
37     myarr = two(10, 20, 30);
38     for(var i = 0; i < 3; i++){
39         myarr[i] = addone(myarr[i]);
40     }
41     alert(myarr);        //output    [21, 41, 61]
42     /*
43      * 以上代码可以工作,但是显然不够优化。
44      * 这里使用了两次循环。如果处理的数据量很大火循环操作很复杂的话,开销一定不小。
45      */
46     
47     //优化之后的代码(修改two函数)
48     function two(a, b, c, callback){
49         var i, arr = [];
50         for(i = 0;i < 3; i++){
51             arr[i] = callback(arguments[i] * 2);
52         }
53         return arr;
54     }
55     
56     myarr = two(1, 2, 3, addone);
57     alert(myarr);        //output    [3, 5, 7]
58     
59     //还可以使用匿名函数来替代addone函数
60     myarr = two(1, 2, 3, function addone(a){return a + 1;});
回调函数.html

            * 自调函数:定义即调用
                      * 第一个小括号:封装函数
                      * 第二个小括号:调用函数(传参)

 1 自调函数
 2 自调函数 —— 其实就是在定义函数后自行调用。例如:
 3 (
 4         function(){
 5             alert("javascript");
 6         }
 7     )()
 8 第一对括号,放置的是一个匿名函数。
 9 第二对括号的作用,是“立即调用”。
10 自调函数只需:将匿名函数的定义放进一对括号中,然后外面再跟一对括号即可。
11 
12         function(name){
13             alert("Hello " + name + "!");
14         }
15     )("javascript")
16     //output    Hello javascript!
17 第一个括号中的匿名函数接受一个参数。
18 第二个括号,在调用时,向匿名函数传递参数内容。
自调函数.html

            * 内部函数:Java中的内部类,提高安全性

 1 内部(私有)函数
 2 function a(param){
 3         function b(input){
 4             return input * 2;
 5         };
 6         return "The result is " + b(param);
 7     }
 8     
 9     alert(a(2));        //The result is 4
10 当调用全局函数a ( ) 时,本地函数b ( ) 也会在其内部被调用。由于b ( ) 是本地函数,
11 它在a ( ) 以外的地方是不可见的,所以将b 称之为私有函数。
12 私有函数的优点:
13 有助于确保全局名字空间的纯净性(这意味着命名冲突的机会很小)。
14 私有性 —— 只将一些必要的函数暴露给“外面世界”,并保留属于自己的函数,使它们不为该应用程序的其他部分所用。
内部函数.html

            * 返回函数的函数

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>01_几种特殊函数.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       /*
19        * 内部(私有)函数(Java里内部类)
20        *     * 保证了私有性 —— 外部不能访问不到(提供了安全性)
21        */
22 //    function fn(){
23 //        var a = "a";
24 //        
25 //        function n(){
26 //            var b = "b";
27 //            
28 //            alert(a+b);        //output    ab
29 //        }
30 //        
31 //        return n();
32 //    }
33 //    
34 //    fn();        //output    ab
35     
36     /*
37      * (了解)返回函数的函数(内部函数的一种特殊用法)
38      *     * 可以在全局域中,访问到局部变量的值
39      *     * 定义一个函数时,最终执行两个逻辑代码块
40      */
41     function fn(){
42         //逻辑代码块
43         var a = "a";
44         
45         return function(){
46             //逻辑代码块
47             return a;
48         }
49     }
50     
51     alert(fn());            //output    function(){return a;}
52     
53     //var fun = fn();
54     //var fun = function(){return a;}
55     
56     //alert(fun());            //output    a
57     
58     alert(fn()());            //output    a
59     
60     /*
61      * javascript中的特殊函数,不是必要使用的内容
62      *     * 第一次完成实现逻辑内容时,很少会用到特殊函数
63      *     * 在做代码优化的时候,会使用特殊函数
64      * 
65      * 代码实现:一次性做到代码最优
66      *     * 实现逻辑内容
67      *     * 代码优化
68      */
69     
70   </script>
71 </html>
返回函数的函数.html

作用域链:

 1 javascript不存在大括号级的作用域,但具有函数作用域。
 2 在函数内定义的变量在函数外是不可见的。但如果该变量是在某个代码块中定义的(如在某个if或for语句中),它在代码块外是可见的。
 3 
 4 var a = 1;
 5     function f(){
 6         var b = 2;
 7         return a;
 8     }
 9     
10     alert(f());        //output    1
11     alert(b);        //output    b is undefined
12 
13 变量a 是属于全局域的,变量b 的作用域是属于函数f ( ) 内。
14 在f ( ) 内,a 和b 都是可见的。
15 在f ( ) 外,a 是可见的,b 则是不可见的。
16 
17 var a = 1;
18     function f(){
19         var b = 2;
20         function n(){
21             var c = 3;
22             alert(a);    //output    1
23             alert(b);    //output    2
24             alert(c);    //output    3
25         }
26         return n();
27     }
28         f();
29 
30 函数n ( ) 可以访问的变量可以是自身的作用域,也可以是其“父级”的作用域。这就形成了一条作用域链
31 function f1(){
32         var a = 1;
33         f2();
34     }
35     function f2(){
36         return a;
37     }
38     
39     alert(f1());    //output    a is undefined
40 
41 在定义函数f1 ( ) 和f2 ( ) 时,只能访问全局作用域和其自身的作用域。
42 在定义函数f2 ( ) 时,变量a 是不可见的。
43 
44 var a = 5;
45     function f1(){
46         var a = 1;
47         f2();
48     }
49     function f2(){
50         return a;
51     }
52     
53     alert(f1());    //output    5
54 
55 在定义函数f1 ( ) 和f2 ( ) 时,都是可以访问全局作用域的。
56     
作用域链.html

 闭包:

定义:指的是词法表示包括不被计算的变量的函数,也就是说,函数可以使用函数之外定义的变量。
闭包的实现:

 1 var b;
 2     function a(){
 3         var a = "a";
 4         b = function(){
 5             return a + "b";
 6         }
 7         return a;
 8     }
 9     
10     //测试
11     alert(a());        //output    a
12     alert(b());        //output    ab
闭包的实现

 

在a ( ) 函数中定义了 b ( ) 函数,所以b ( ) 函数可以访问a ( ) 函数的作用域。
将 b ( ) 函数升级到全局函数,但依然保留可以对a ( ) 函数作用域的访问权。

 1 function f(){
 2         var a = [];
 3         var i;
 4         for(i = 0; i < 3; i++){
 5             a[i] = function(){
 6                 return i;
 7             }
 8         }
 9         return a;
10     }
11     
12     var fun = f();
13     
14     alert(fun[0]());        //output    3
15     alert(fun[1]());        //output    3
16     alert(fun[2]());        //output    3
循环中的闭包1

按照预期,最终结果应该输出 [0 , 1 , 2 ],但是却是[ 3 , 3 , 3 ]。
在函数 f ( ) 中,我们通过循环,创建了三个闭包,它们都指向了共同的局部变量 i 。
但是,闭包并不会记录它们的值,它们所拥有的只是一个 i 的连接(即引用),因此只能返回i 的当前值。

 1 function f(){
 2     var a = [];
 3     var i;
 4     for(i = 0; i < 3; i++){
 5         a[i] = (function(x){
 6             return x;
 7         })(i);
 8     }
 9     return a;
10 }
11     
12 var fun = f();
13     
14 alert(fun[0]);        //output    0
15 alert(fun[1]);        //output    1
16 alert(fun[2]);        //output    2
循环中的闭包2

在这里,我们不再直接创建一个返回i 的函数,而是将i 传递给了一个自调函数。
在该自调函数中,i 就被赋值给了局部变量x ,这样一来,每次迭代中的x 就会拥有各自不同的值了。

 1 function f(){
 2         function n(x){
 3             return x;
 4         }
 5         var a = [];
 6         var i;
 7         for(i = 0; i < 3; i++){
 8             a[i] = n(i);
 9         }
10         return a;
11     }
12     
13     var fun = f();
14     
15     alert(fun[0]);        //output    0
16     alert(fun[1]);        //output    1
17     alert(fun[2]);        //output    2
循环中的闭包3

上面这种,是不使用自调函数的用法

对象    

    * 定义对象:
            * 普通对象
                * new Object()
                * var 对象名 = {
                    属性名 : 属性值,
                    方法名 : function(参数){}
                }

 1  <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>01_如何定义对象.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       //1 在javascript中,底层存在Object对象:Object对象应该所有对象的父级.
19     var obj1 = new Object();
20     
21     //2 JSON的key/value格式,Java中的Map集合
22     var ob2 = {};
23     
24     //3 在javascript中,函数即对象:函数对象(我起的)
25     function obj3(){}
26         
27   </script>
28 </html>
如何定义对象
 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>02_定义对象的属性和方法.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       //定义普通对象的属性和方法(JSON的key/value格式)
19     var hero = {
20         name : "zhangwuji",
21         sayMe : function(){
22             alert("i am zhangwuji.");
23         }
24     }
25     
26     //定义函数对象的属性和方法
27     function Hero(){
28         this.name = "zhangwuji";
29         this.sayMe = function(){
30             alert("i am zhangwuji.");
31         }
32     }
33     
34     /*
35      * this的用法:
36      *     * 指代DOM对象
37      *     * 指代jQuery对象
38      *     * 指代javascript对象
39      */
40     
41     
42   </script>
43 </html>
定义对象的属性和方法

         * 函数对象
                function 对象名(参数){
                    this.属性名 = 属性值;
                    this.方法名 = function(参数){}
                }
        * 调用对象:
            * 普通对象:
                * 调用:
                    * 第一种:
                        * 对象名.属性名;
                        * 对象名.方法名();
                    * 第二种:
                        * 对象名['属性名'];
                        * 对象名['方法名']();
                * 增加:
                    * 对象名.新的属性名 = 新的属性值;
                    * 对象名.新的方法名 = 新的function(){}
                * 修改:
                    * 对象名.属性名 = 新的属性值;
                    * 对象名.方法名 = 新的function(){}
                * 删除:
                    * delete 对象名.属性名;
                    * delete 对象名.方法名;

            * 函数对象:
                * 概念性理解:
                    * 函数对象的概念,实际上是不存在的
                    * 函数对象实际上是叫做构造器
                    * var 对象名 = new 构造器();
                * 获取到函数对象(构造器)的属性和方法
                    * var 对象名 = new 构造器();
                    * 调用、修改、删除及增加与操作普通对象一致。

 

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>03_调用对象的属性和方法.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       //普通对象
19 //    var hero = {
20 //        name : "zhangwuji",
21 //        sayMe : function(){
22 //            alert("i am zhangwuji.");
23 //        }
24 //    }
25     
26     //调用普通对象hero的属性和方法
27     //1 
28 //    alert(hero.name);
29 //    hero.sayMe();
30     
31     //2 
32 //    alert(hero['name']);
33 //    hero['sayMe']();
34     
35     //增加普通对象hero的属性和方法
36     //hero.value = "zhouzhiruo";
37     //alert(hero.value);
38 //    hero.sayVal = function(){
39 //        alert("zhangwuji's value is zhouzhiruo.");
40 //    }
41 //    hero.sayVal();
42     
43     //修改普通对象hero的属性和方法
44     //hero.name = "zhouzhiruo";
45     //alert(hero.name);
46 //    hero.sayMe = function(){
47 //        alert("i am zhouzhiruo.")
48 //    }
49 //    hero.sayMe();
50     
51     //删除普通对象hero的属性和方法
52 //    delete hero.name;
53 //    alert(hero.name);
54     
55 //    delete hero.sayMe;
56 //    hero.sayMe();
57     
58     /*
59      * 函数对象:类似于Java中的类的概念
60      *     * 实际上,是不存在函数对象的概念的(是我们自己起的名)
61      *     * 函数对象实际上是叫做构造器
62      */
63     function Hero(){
64         this.name = "zhangwuji";
65         this.sayMe = function(){
66             alert("i am zhangwuji.");
67         }
68     }
69     
70     /*
71      * 调用之前,必须要先new对象
72      *     * 这里的写法是构造函数的写法
73      *     * hero也是javascript对象,是一个普通对象
74      */
75     var hero = new Hero();
76     
77     //调用函数对象Hero的属性和方法
78 //    alert(hero.name);
79 //    alert(hero['name']);
80     
81 //    hero.value = "zhouzhiruo";
82 //    alert(hero.value);
83     
84 //    delete hero.name;
85 //    alert(hero.name);
86     
87     hero.name = "zhouzhiruo";
88     alert(hero.name);
89     
90 //    class A(){
91 //        String name = "zhangwuji";
92 //    }
93 //    
94 //    A a = new A();
95 //    a.name
96     
97   </script>
98 </html>
调用对象的属性和方法

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>04_this的用法.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       /*
19        * this的用法:
20        *     * 指代DOM对象(常用)
21        *     * 指代JQuery对象(最不常用)
22        *     * 指代javascript对象(居中)
23        * 
24        * this的实际用法,不止以上三种.
25        */
26     //1 指代DOM对象
27 //    document.getElementById("ok").onclick = function(){
28 //        this.value;
29 //    }
30     
31     //2 指代jQuery对象:在jQuery的插件中使用
32     $.each(this,function(){
33         alert(this.value);
34     });
35     
36     //3 指代javascript对象:只要在函数对象中,使用this的话,this永远都指代函数对象
37     function Hero(){
38         this.name = "zhangwuji";
39         this.sayMe = function(){
40             alert("hello "+this.name);
41         }
42     }
43     
44     var hero = new Hero();
45     
46     hero.sayMe();
47     
48   </script>
49 </html>
this的用法

内建对象:
            * 数据封装类对象
                * String、Array、Number等
            * 工具类对象
                * Date、Math等
            * 错误类对象
                * Error、异常对象等
    * 在javascript中,只有对象(变量、方法、集合等)
        * javascript是更纯粹的面向对象

 

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>05_举例.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       //定义一个字符串
19     var str = "aaaa";
20     //定义一个数值
21     var i = 7;
22     //定义一个数组
23     var arr = [1,2,3,4,5];
24     
25     /*
26      * 这些所谓的常用类型,可以直接使用
27      *     * 这种方式类似于Java中JDK提供的常用类型
28      *     * 说明在javascript的底层,提供了类似的常用类型
29      * 
30      * javascript的内建对象:Java中的API提供的常用类型
31      *     * javascript内建对象:帮助文档"w3school.chm"
32      *     * javascript的内容并不像java一样,具有完整的帮助文档.(javascript没有完整的帮助文档)
33      */
34     
35   </script>
36 </html>
内建对象

Array:

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>02_Array对象.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       //以下两种写法是等价的
19     var arr1 = [];
20     var arr2 = new Array();
21     
22     alert(typeof arr1);        //object
23     alert(typeof arr2);        //object
24     
25     //Array对象的属性
26     //1 length属性:获取数组长度
27     //alert(arr1.length);
28     
29     //2 index和input属性,放弃的
30     
31     //3 constructor属性:返回对创建此对象的数组函数的引用。(不研究)
32     
33     //4 prototype属性:使您有能力向对象添加属性和方法。(现在不研究,统一放在原型的内容)
34     
35     //Array对象的方法
36     //1 toString()方法:把数组转换为字符串,并返回结果。
37     
38     //2 join()方法:把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。
39     
40     //3 pop()和push()方法:删除并返回数组的最后一个元素;向数组的末尾添加一个或更多元素,并返回新的长度。
41     
42     //4 reverse()方法:颠倒数组中元素的顺序。
43     
44     //javascript的内建对象的属性和方法,在Java中的JDK的内容,都有类似的内容
45     
46     //反转字符串示例(面试题)
47     
48     //定义一个字符串
49     var str = "abcdefg";
50     //利用String对象的split()方法,将字符串切割成一个数组
51     var arr = str.split("");
52     //利用Array对象的reverse()方法,将数组中元素的顺序颠倒。
53     arr = arr.reverse();
54     //测试打印
55     alert(arr.toString());
56     
57     //Java的版本至少在1.5版本以上
58 
59     
60   </script>
61 </html>
Array对象

String:

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>03_String对象.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       //以下两种写法不是等价的(面试)
19     var str1 = "aaa";
20 //    var str2 = new String("aaa");
21 //    
22 //    alert(typeof str1);        //string
23 //    alert(typeof str2);        //object
24     
25     //String对象的属性
26     //length属性:字符串的长度(字符的个数)
27     //alert(str1.length);        //3
28     
29     //String对象的方法
30     //1 substr():从起始索引号提取字符串中指定数目的字符。
31     //2 substring():提取字符串中两个指定的索引号之间的字符。
32     
33     //3 split():把字符串分割为字符串数组。
34     
35     //4 replace():替换与正则表达式匹配的子串。
36     
37     //判断字符串是否包含指定字符串示例
38     
39     //定义两个要判断的字符串
40     var str = "abcdefg";
41     var substr = "xyz";
42     
43     function sub(str,substr){
44         //将判断的字符串定义成String对象
45         var string = new String(str);        //不必要,更规范一些
46         //截取判断的字符串
47         var result = string.substr(string.indexOf(substr),substr.length);
48         
49         if(result==substr){
50             return true;
51         }else{
52             return false;
53         }
54     }
55     
56     alert(sub(str,substr));
57 
58   </script>
59 </html>
String对象

Events对象:

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>04_Events对象.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       /*
19        * Event:事件
20        * Events对象:事件对象
21        *     * 在javascript中,具有事件的.
22        *         onclick\ondblclick\onchange等
23        *     * 事件对象与之前使用的事件内容,是否存在关系?
24        *         之前使用的事件内容,其实是javascript中事件对象的属性.
25        */
26     
27     
28     
29   </script>
30 </html>
Events对象

Functions对象

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>05_Functions对象.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       /*
19        * Functions对象:javascript全局对象
20        *     * 全局属性:
21        *         * NaN:表示不是一个数值
22        *         * undefined:未定义
23        *     * 全局方法
24        *         * decodeURI():解码某个编码的 URI。
25        *         * encodeURI():把字符串编码为 URI。
26        *         * escape():对字符串进行编码。
27        *         * eval():计算 JavaScript 字符串,并把它作为脚本代码来执行。
28        *         * isNaN():检查某个值是否是数字。返回值为Boolean值,true不是数字.
29        * 
30        * Functions对象与Function对象:是不是一个?
31        *     * Function对象实际上,浏览器内核中集成的javascript引擎里.
32        *     * 对于Function对象,我们只需要了解new Function()定义函数即可.
33        */
34     
35     
36     
37     
38   </script>
39 </html>
Functions对象.html

Object对象:

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>01_Object对象.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       //以下两种写法是等价的(面试题)
19     var obj1 = new Object();
20     var obj2 = {};
21     
22     //Object对象是所有javascript对象的父级.
23     
24     //面试题(真实)
25     //判断以下哪个描述是错误的?D
26 //    var a = {};        //定义对象
27 //    var b = [];        //定义数组
28 //    var c = //;        //定义正则表达式
29 //    var d = ();
30     
31     //面试题(百度)
32     //alert():提示框,在提示框中实现换行
33     alert("xxx\nyyy");
34     
35     
36   </script>
37 </html>
Object对象.html

 更多参考W3cSchool帮助文档

原型(prototype):及其重要(作用)
        * 定义:原型就是一个函数对象的属性。(记住是函数对象function XXX{  name:xxx......  })


        * 作用:
            * 利用原型为函数对象增加属性和方法

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>01_研究函数对象的原型属性.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       //原型是函数对象的一个属性(普通对象是没有原型属性的.).
19     function Hero(){
20         this.name = "zhangwuji";
21         this.sayMe = function(){
22             alert("i am zhangwuji.");
23         }
24     }
25     
26     //调用函数对象Hero的属性和方法:new Hero()
27     var hero = new Hero();
28     
29     //调用函数对象Hero的属性或方法时,实际上调用new之后的hero对象.
30     //alert(hero.name);
31     
32     //调用函数对象的原型属性,是应该调用Hero对象还是hero对象呢?
33     //hero.prototype;
34     Hero.prototype;
35     
36     
37     
38     
39   </script>
40 </html>
研究函数对象的原型属性.html

 

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>02_利用原型增加函数对象的属性或方法.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is m
16 <script type="text/javascript">
17 //    function Hero(){
18 //        this.name = "zhangwuji";
19 //        this.sayMe = function(){
20 //            alert("i am zhangwuji.");
21 //        }
22 //    }
23     
24     //普通对象
25 //    var hero = new Hero();
26     
27     //hero.value = "zhouzhiruo";
28     
29     //利用原型为函数对象增加属性或方法.
30     //函数对象.prototype.新的属性名 = 新的属性值;
31     //Hero.prototype.value = "zhouzhiruo";
32     
33     //alert(hero.prototype.value);        //output    zhouzhiruo
34     //alert(hero.value);
35     
36 //    Hero.prototype.sayVal = function(){
37 //        alert("i am zhouzhiruo.");
38 //    }
39 //    
40 //    alert(hero.sayVal());
41     
42     //利用原型增加的属性和方法与上午说的增加属性和方法的区别?利用原型增加属性和方法更优
43     //1 定义一个函数对象
44     function Hero(){
45         this.name = "zhangwuji";
46         this.sayMe = function(){
47             alert("i am zhangwuji.");
48         }
49     }
50     
51     //2 (分散形式)利用原型增加属性和方法
52 //    Hero.prototype.value = "zhouzhiruo";
53 //    Hero.prototype.sayVal = function(){
54 //        alert("i am zhouzhiruo.");
55 //    }
56     
57     //学习JSON时
58 //    var method = {
59 //        add : function(a,b){
60 //            return a+b;
61 //        }
62 //    }
63     
64     /*
65      * (集中方式)将增加属性和方法的内容,集中写在一起
66      *     * 格式:函数对象.prototype = 新的对象
67      *     * 注意:只能先增加,再new对象
68      * (分散形式)
69      *     * 先new对象和后new对象,没有关系
70      */
71     Hero.prototype = {
72         value : "zhouzhiruo",
73         sayVal : function(){
74             alert("i am zhouzhiruo.");
75         }
76     }
77     
78     //3 new对象
79     var hero = new Hero();
80     
81     //4 测试
82     alert(hero.value);
83     hero.sayVal();
84     
85 </script>
86 </html>
利用原型增加函数对象的属性或方法.html

            * 函数对象的属性或方法与原型的属性或方法同名时:
                * 函数对象本身的属性和方法的优先级要高于原型上的熟悉感和方法
                * 利用函数对象的属性和方法重写原型上的属性和方法

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>03_函数对象的属性或方法与原型的属性和方法同名.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       /*
19        * 函数对象的属性或方法与原型的属性或方法同名时:
20        *     * 调用的属性和方法,是函数对象的属性和方法
21        *     * 函数对象本身的属性和方法与原型的属性和方法同时存在
22        *     * 函数对象本身的属性和方法的优先级要高于原型上的熟悉感和方法
23        */
24     function Hero(){
25         this.name = "zhangwuji";
26         this.sayMe = function(){
27             alert("i am zhangwuji.");
28         }
29     }
30     
31     //原型增加的属性和方法,到底有没有增加上去呢?
32     Hero.prototype = {
33         name : "zhouzhiruo",
34         sayMe : function(){
35             alert("i am zhouzhiruo.");
36         }
37     }
38     
39     var hero = new Hero();
40     
41     alert(hero.name);            //output    zhangwuji
42     
43     delete hero.name;
44     
45     alert(hero.name);            //output    zhouzhiruo
46     
47     
48     
49   </script>
50 </html>
函数对象的属性或方法与原型的属性和方法同名.html

 

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>04_利用原型重新定义函数对象.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       //定义一个空的函数对象
19     function Hero(){}
20     
21     //函数对象的属性和方法,都定义在原型上
22     Hero.prototype = {
23         name : "zhangwuji",
24         sayMe : function(){
25             alert("i am zhangwuji.");
26         }
27     }
28     
29   </script>
30 </html>
利用原型重新定义函数对象.html

            * 内建对象(应该都是函数对象):都有prototype属性
                * 可以扩展内建对象的属性和方法

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>05_扩展内建对象的属性和方法.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18 //  //为原型 Array对象增加一个判断的函数
19 //    Array.prototype.inArray = function(color){
20 //        //this指代Array对象
21 //        for(var i = 0, len = this.length; i < len; i++){
22 //            //"==="叫全等号:值和类型;"!=="叫全不等号
23 //            if(this[i] === color){
24 //                return true;
25 //            }
26 //        }
27 //        return false;
28 //    }
29 //        
30 //    //定义一个Array对象
31 //    var a = ["red", "green", "blue"];
32 //        
33 //    //测试
34 //    alert(a.inArray("red"));        //true
35 //    alert(a.inArray("yellow"));        //false
36 
37     function inArray(arr,color){
38         for(var i = 0, len = arr.length; i < len; i++){
39             //"==="叫全等号:值和类型;"!=="叫全不等号
40             if(arr[i] === color){
41                 return true;
42             }
43         }
44         return false;
45     }
46     
47     var a = ["red", "green", "blue"];
48     
49     alert(inArray(a,"red"));    //output    true
50     
51     /*
52      * 以上两种写法哪种更好?
53      *     * (更好)一种通过原型扩展内建对象
54      *     * 自定义函数完成需求
55      * 但是,一般不建议大家使用原型来扩展内建对象.
56      *     * 扩展内建对象这种方式不好.(内建对象是底层提供的,最好不要修改)
57      * 但是,介绍js库的时候,有prototype.
58      *     * 对于javascript原型这个概念,讨论的是比较激烈?
59      *         * (A)正面,支持这种用法,代表性的是prototype库.
60      *         * (B)反面,不支持.
61      * 关于利用原型扩展内建对象,了解即可.
62      */
63     
64     
65   </script>
66 </html>
扩展内建对象的属性和方法.html

 
继承:
        * 定义:如果两个类都是同一个实例的类型,那么它们之间存在着某些关系,
                我们把同一个实例的类型之间的泛化关系称为“继承”。

如果两个类都是同一个实例的类型,那么它们之间存在着某些关系,我们把同一个实例的类型之间的泛化关系称为“继承”。
继承关系至少包含三层含义:
子类的实例可以共享父类的方法。
子类可以覆盖父类的方法或扩展新的方法。
子类和父类都是子类实例的“类型”。
在javascript中,并不支持“继承”。也就是说,javascript中没有继承的语法。从这个意义上来说,javascript并不是直接的面向对象语言。
        * 问题:
            * 在javascript中,是不存在继承的关系的(关键字 extend)!
            * 在javascript中,没有类的概念。
            * javascript就不是一个直接的面向对象语言。
        * "继承":
            * javascript中函数对象与函数对象之间的继承。

 

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>01_利用原型实现继承.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       function A(){
19         this.a = "a";
20         this.sayA = function(){
21             alert("this is a.");
22         }
23     }
24     
25     var a = new A();
26     
27     function B(){
28         this.b = "b";
29         this.sayB = function(){
30             alert("this is b.");
31         }
32     }
33     
34     B.prototype = a;
35     
36     //测试:函数对象B就"继承"了函数对象A
37     var b = new B();
38     
39 //    alert(b.b);
40 //    b.sayB();
41 //    
42 //    alert(b.a);
43 //    b.sayA();
44     
45 //    b.a = "c";
46 //    b.sayA = function(){
47 //        alert("this is c.")
48 //    }
49 //    
50 //    alert(b.a);
51 //    b.sayA();
52     
53 //    b.c = "c";
54 //    b.sayC = function(){
55 //        alert("this is c.")
56 //    }
57 //    
58 //    alert(b.c);
59 //    b.sayC();
60     
61   </script>
62 </html>
利用原型实现继承.html

 

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>02_只继承于原型.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18 //  function A(){
19 //        this.a = "a";
20 //        this.sayA = function(){
21 //            alert("this is a.");
22 //        }
23 //    }
24 //    
25 //    function B(){
26 //        this.b = "b";
27 //        this.sayB = function(){
28 //            alert("this is b.");
29 //        }
30 //    }
31 //    
32 //    B.prototype = A.prototype;
33 //    
34 //    //测试
35 //    var b = new B();
36 //    
37 //    alert(b.a);
38 //    b.sayA();
39     
40     /******************************************/
41     
42 //    function A(){}
43 //    
44 //    A.prototype = {
45 //        a : "a",
46 //        sayA : function(){
47 //            alert("this is a.")
48 //        }
49 //    }
50 //    
51 //    function B(){}
52 //    
53 //    B.prototype = {
54 //        b : "b",
55 //        sayB : function(){
56 //            alert("this is b.")
57 //        }
58 //    }
59 //    
60 //    B.prototype = A.prototype;
61 //    
62 //    var b = new B();
63 //    
64 ////    alert(b.a);
65 ////    b.sayA();
66 //    
67 //    alert(b.b);
68 //    b.sayB();
69     
70     /***************************************/
71     
72     function A(){}
73     
74     A.prototype = {
75         a : "a",
76         sayA : function(){
77             alert("this is a.")
78         }
79     }
80     
81     function B(){
82         this.b = "b";
83         this.sayB = function(){
84             alert("this is b.");
85         }
86     }
87     
88     B.prototype = A.prototype;
89     
90     var b = new B();
91     
92     alert(b.b);
93     b.sayB();
94     
95     alert(b.a);
96     b.sayA();
97     
98   </script>
99 </html>
只继承于原型.html

 

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>03_解决多函数对象之间的继承关系.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       function A(){}
19     
20     A.prototype = {
21         a : "a",
22         sayA : function(){
23             alert("this is a.")
24         }
25     }
26     
27     function B(){}
28     
29     //这种方式利用原型为函数对象B增加属性和方法(集中方式)
30 //    B.prototype = {
31 //        b : "b",
32 //        sayB : function(){
33 //            alert("this is b.")
34 //        }
35 //    }
36     
37     //分散形式
38 //    B.prototype.b = "b";
39 //    B.prototype.sayB = function(){
40 //        alert("this is b.")
41 //    }
42     
43     /*
44      * 分析得出这句话出问题了
45      *     * 因为B.prototype多次调用
46      *         * 出现的顺序有关系?谁先定义,谁被覆盖
47      *         * 原型定义属性和方法的形式有关系?没有关系
48      */
49     B.prototype = A.prototype;
50     
51 //    B.prototype = {
52 //        b : "b",
53 //        sayB : function(){
54 //            alert("this is b.")
55 //        }
56 //    }
57     
58     /*
59      * 条件:
60      *     * 先实现函数对象B"继承"函数对象A的内容
61      *     * 再利用原型为函数对象B增加属性和方法(分散形式)
62      */
63     B.prototype.b = "b";
64     B.prototype.sayB = function(){
65         alert("this is b.")
66     }
67     
68     var b = new B();
69     
70     alert(b.a);
71     b.sayA();
72     
73     alert(b.b);
74     b.sayB();
75     
76     
77     
78     
79   </script>
80 </html>
解决多函数对象之间的继承关系.html

 

 

 

 

 

原型链

 1 原型链是ECMAScript标准制定的默认继承方式。
 2 function A(){
 3         this.name = "a";
 4         this.toString = function(){return this.name};
 5     }
 6     function B(){
 7         this.name = "b";
 8     }
 9     function C(){
10         this.name = "c";
11         this.age = 18;
12         this.getAge = function(){return this.age};
13     }
14     
15     B.prototype = new A();
16     C.prototype = new B();
17 将对象直接创建在B对象的prototype属性中,并没有去扩展这些对象的原有原型。
18 通过new A ( ) 另创建了一个新的实体,然后用它去覆盖该对象的原型。
19 javascript是一种完全依靠对象的语言,其中没有类(class)的概念。
20 因此,需要直接用new A ( ) 创建一个实体,然后才能通过该实体的属性完成相关的继承工作。
21 完成这样的继承实现之后,对 A ( ) 所进行的任何修改、重写或删除,都不会对 B ( ) 产生影响。
22 
23 只继承于原型:
24 function A(){}
25 A.prototype.name = "a";
26 A.prototype.toString = function(){return this.name};
27     
28 function B(){}
29 B.prototype = A.prototype;
30 B.prototype.name = "b";
31     
32 function C(){}
33 C.prototype = B.prototype;
34 C.prototype.name = "c";
35 C.prototype.age = 18;
36 C.prototype.getAge = function(){return this.age};
37 
38 对象之间的继承(扩展内容,可以不会)(浅复制)
39 //该函数接受一个对象并返回它的副本
40 function extendCopy(p){
41     var z = {};    //定义一个空的对象z
42     for(var i in p){    //var i =0 ; i < p.length ; i++
43         z[i] = p[i];    //都当做数组处理的话,可以理解
44     }
45     //uber属性:将p作为z的父级,将z指向p的原型
46     z.uber = p;
47     return z;
48 }
49 //定义对象a,但是对象a不是函数对象    
50 var a = {
51     name : "a",
52     toStr : function(){return this.name;}
53 }
54 //定义对象b,但是对象b不是函数对象    
55 var b = extendCopy(a);
56 b.name = "b";
57 b.toStr = function(){return this.uber.toStr() + " , " + this.name;};
58 //定义对象c,但是对象c不是函数对象    
59 var c = extendCopy(b);
60 c.name = 18;
61     
62 alert(c.toStr());        //output    a , b , 18
原型链

 * (了解)javascript中的普通对象之间,是否也存在"继承"关系呢?存在

 1 <!DOCTYPE html>
 2 <html>
 3   <head>
 4     <title>04_普通对象之间的继承.html</title>
 5     
 6     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 7     <meta http-equiv="description" content="this is my page">
 8     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 9     
10     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
11 
12   </head>
13   
14   <body>
15     This is my HTML page. <br>
16   </body>
17   <script type="text/javascript">
18       //对象之间的继承
19     
20     //该函数接受一个对象并返回它的副本
21     function extendCopy(p){
22         var z = {};    //定义一个空的对象z
23         for(var i in p){    //var i =0 ; i < p.length ; i++
24             z[i] = p[i];    //都当做数组处理的话,可以理解
25         }
26         //uber属性:将p作为z的父级,将z指向p的原型
27         z.uber = p;
28         return z;
29     }
30     //定义普通对象a,但是对象a不是函数对象    
31     var a = {
32         name : "a"
33     }
34     //暂且将b也当作普通对象来看待
35     var b = extendCopy(a);
36     b.toStr = function(){return this.name;};
37         
38     alert(b.toStr());        //output    a
39 
40   </script>
41 </html>
普通对象之间的继承.html

 

 

转载于:https://www.cnblogs.com/biaogejiushibiao/p/9428210.html

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/367909.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

绘图用计算机软件的基本种类有,主编教您电脑绘图软件有哪些

绘图软件是指专业人员根据一定准则设计的用于计算机绘图软件程序&#xff0c;种类非常多&#xff0c;通过它们可以满足足广大用户的基本绘图要求。下面&#xff0c;我就给大家介绍电脑绘图软件有哪些。电脑是根据指令进行高速计算的电子设备&#xff0c;功能强大&#xff0c;时…

HTML浮动导致高度塌陷,HTML 文档流,设置元素浮动,导致父元素高度无法自适应的解决方法(高度欺骗)...

元素浮动定义float 属性定义元素在哪个方向浮动。以往这个属性总应用于图像&#xff0c;使文本围绕在图像周围&#xff0c;不过在 CSS 中&#xff0c;任何元素都可以浮动。浮动元素会生成一个块级框&#xff0c;而不论它本身是何种元素。如果浮动非替换元素&#xff0c;则要指定…

Python API简单验证

前言 因为CMDB内部的需求&#xff0c;需要一个API进行数据传输&#xff0c;用来传递需要抓取的服务端信息信息给抓取的autoclient&#xff0c;autoclient抓取好之后再通过API传输到服务器&#xff0c;保存到数据库。但是为了防止恶意的API访问&#xff0c;需要做一个验证。 设想…

前端js编码

1、首先是encodeURI和encodeURIComponent&#xff1b; 从名字可以清晰的看出他两都是主要用于url编码的&#xff0c;那之间有什么区别呢&#xff1f;唯一区别就是编码的字符范围&#xff0c;其中 encodeURI方法不会对下列字符编码 ASCII字母、数字、~!#$&*():/,;?&#x…

Python中 sys.argv[]的用法简明解释

Python中 sys.argv[]的用法简明解释 因为是看书自学的python,开始后不久就遇到了这个引入的模块函数&#xff0c;且一直在IDLE上编辑了后运行&#xff0c;试图从结果发现它的用途&#xff0c;然而结果一直都是没结果&#xff0c;也在网上查了许多&#xff0c;但发现这个问题的比…

文件上传漏洞及其绕过、对策、过狗

1. 文件包含上传&#xff1a; php://input属于php内置的封装协议&#xff0c;其实都主要是include&#xff08;&#xff09;函数处理不当如果有文件是以下写法&#xff0c;xxx随便&#xff1a;<?phpinclude($_GET[xxx]);?> 以上保存到test.php&#xff0c; 我们访问ht…

一维二维_更高效的一维、二维材料过渡态搜索

前言本文中&#xff0c;我们首先介绍如何使用NEB方法搜索过渡态&#xff0c;以及在NEB的结果的基础上&#xff0c;进一步提高精度优化出高精度、可验证的过渡态。本文以MoS2的一维条带(其中一个Mo原子被Co替代掺杂)为例进行演示。一般来说&#xff0c;这种反应&#xff0c;周期…

Mybatis之逆向工程

前面几篇基本把mybatis简单使用学习了下,今天学习下mybatis逆向工程&#xff0c;我们在开发中经常需要先设计数据库表结构或者先设计model,那就是能不能有工具可以只需在一边设计之后另一边自动生成呢&#xff1f;于是逆向工程来了。这里的逆向功能是通过数据库的表生成java po…

2023航天推进理论基础考试划重点(W老师)-液体火箭发动机1

适用于期末周求生欲满满的西北工业大学学生。 1、液体火箭发动机的基本组成及功能是什么&#xff1f; 推力室组件、推进剂供应系统、阀门与调节器、发动机总装元件等组成。 2、液体火箭发动机的分类和应用是什么&#xff1f;3、液体火箭发动机系统、分系统的概念是什么&…

Java EE 7是最终版本。 思想,见解和进一步的指针。

我们花了不到三年的时间才推出了下一个Java EE版本 。 今年4月16日&#xff0c; JCP EC对JSR 342进行了投票并获得批准。 这是一个成功的故事&#xff0c;因为在去年八月下旬的最后时刻撤消了拥有云就绪平台的最初想法。 作为EG的成员&#xff0c;撰写即将发布的功能或多或少容…

dbgrideh指定某单元格变色_一招搞定按指定名称批量新建文件夹

文 / 雷哥小鱼儿 编辑 / 小瓜子假如你有一个100行的Excel名单文件。业务需要&#xff0c;需要按姓名单独做成一个个文件夹。普通小白做法&#xff1a;用复制粘贴大法一个个去修改文件夹名字........雷哥Tips&#xff1a;EXCEL中为了实现某目标&#xff0c;出现了N次重复的操作…

如何编写自己的Java / Scala调试器

通过这篇文章&#xff0c;我们将探讨Java / Scala调试器的编写和工作方式。 诸如Windows的WinDbg或Linux / Unix的gdb之类的本机调试器通过操作系统直接提供给它们的钩子来获取其强大功能&#xff0c;以监视和操纵外部进程的状态。 JVM充当OS之上的抽象层&#xff0c;它提供了自…

软件测试bug文档模板,软件bug测试记录模板

软件bug测试记录模板 XXX软件bug测试记录表 文档编号&#xff1a; 背景信息 项目名称 测试目的 硬件环境 软件环境 测试时间 测试人员 测试说明 1、严重等级&#xff1a; A-Crash(崩溃的)&#xff1a;由于程序所引起的死机、非法退出、死循环&#xff1b;数据库发生死锁&#x…

Java即时编译:不仅仅是一个流行词

最近的Java生产性能问题迫使我重新审视并真正欣赏Java VM即时&#xff08;JIT&#xff09;编译器。 大多数Java开发人员和支持人员都听说过这种JVM运行时性能优化&#xff0c;但是有多少人真正理解并欣赏它的好处&#xff1f; 本文将与您分享在添加新的虚拟服务器&#xff08…

win10设置计算机关机时间,教你windows10电脑怎么设置定时关机

今天小编教你windows10电脑怎么设置定时关机&#xff0c;相信大家都有过这样的经历吧!那就是有时开着电脑玩累了,躺在床上睡了一会&#xff0c;结果醒来的时候发现睡了比较久&#xff0c;且还不愿意下床关电脑怎么办&#xff0c;其实我们可设置定时关机&#xff0c;有需要的用户…

Android内存优化9 内存检测工具3 MAT比Menmery Monitor更强大

在Android性能优化第&#xff08;一&#xff09;篇---基本概念中讲了JAVA的四大引用&#xff0c;讲了一下GCRoot&#xff0c;第二篇Memory Monitor检测内存泄露仅仅说了Menmery Monitor的使用&#xff0c;这篇博客谈一下MAT来寻找内存泄露&#xff0c;相对来说&#xff0c;Memo…

计算机三种引用方式,单元格的引用方式有哪几种

EXCEL单元格的引用包括绝对引用、相对引用和混合引用三种。单元格引用是Excel中的术语&#xff0c;指用单元格在表中的坐标位置的标识。是计算机基础的重要学习内容。1、绝对引用&#xff1a;单元格中的绝对单元格引用(例如$F$6)总是在指定位置引用单元格F6。如果公式所在单元格…

linux上php指向mysql_linux环境下 php如何配置mysql

展开全部Linux下配置安装PHP环境参考别人的做法,遇到问题上网查,下面就是安装步骤.一、安装Apache2.2.221、到官网下636f707962616964757a686964616f31333339666133载 http://httpd.apache.org/download.cgi2、解压tar -zxvf httpd-2.2.22.tar.gz3、建立目标文件夹(注意以下所有…

Java 7 Swing:创建半透明和成形的Windows

Java 7 Swing支持具有透明和非矩形形状的窗口。 以下屏幕截图显示了创建的不透明度为75&#xff05;的圆形窗口。 您可以通过在JFrame上使用setOpacity方法更改其不透明度来创建半透明窗口。 请注意&#xff0c;只有底层操作系统支持时&#xff0c;您才能创建半透明窗口。 另外…

mac mysql创建本地数据库_【mac】配置本地数据库

1.【安装数据库】brew 安装mysql -- brew install mysql安装成功后在命令行敲入 which mysql 查看安装路径2.【配置数据库】如果直接打mysql会报错&#xff0c;需要将mysql添加到环境变量&#xff0c;具体方法参阅后台学习-环境变量检查mysql是否启动 ps -ef | grep mysqld开启…