星座JavaScript学习总结【8】、面向对象编程

selectm.*,n.总分,n.平均分

2、对象的结合

  目标可是分为宿主对象,本地对象及停放对象。

  宿主对象就是 DOM 和
BOM,即由浏览器提供的目标。

  当地对象为非静态对象,所谓本地对象,就是要先
new,再以。常用的靶子要:Object、Function、Array、String、Boolean、Number、Date、RegExp、Error。

  搭对象也静态对象,就是勿需要
new,直接可以应用的近乎。Math
是极端广泛,也是可以一直使用的独自部分坐对象。

  面向对象的首先步,就是如果创建对象。典型的面向对象编程的言语都在
“类”(class)
这样一个定义,所谓类,就是目标的悬空,表示有平等接近东西的共同特性,
比如水果,而目标就是是接近的现实实例,比如苹果就是是水果的一样栽,看似是空洞的,不占用内存,而目标是现实的,占用存储空间。但是以
JS 中尚无 “类” 这个定义,不过可以以构造函数实现。

  之前我们说过,所谓”构造函数”,就是用来创造新目标的函数,作为靶子的骨干组织,一个构造函数,可以创造多个目标,这些目标都出同等的结构。构造函数就是一个普普通通的函数,但是他的性状及用法及一般性函数不均等。**构造函数的极端充分特色就是是,**在创建对象时得采用 new
关键字,并且函数体内部可以使用 this
关键字,代表了所要创建的目标实例,this
就用于因为函数执行时之目前目标。
具体情况下面我们再开分析,现在优先来研讨下对象的结。

  其实我们已掌握了靶的定义,也便不难看出他是由于什么做的,目标就是是出于属性与方式结合的,JS
中举都对象,
那以 JS 中,属性与章程到底该怎么亮为?属性就是变量,方法就是是函数。属性代表状态,就如动物之习性记录他现实是啊一样栽动物一律,他是静态的,变量名称为堪说凡是方名称,是指向艺术的描述。而艺术为就是是行为,是完结某种任务之长河,他是动态的。

 

exec(@sql)

4、构造函数

  构造函数(英文:constructor)就是一个屡见不鲜的函数,没什么区别,然而为什么而为”构造”函数呢?并无是此函数有什么特别,而是以此函数的作用产生一部分专门,跟别的函数就无平等,那便是构造函数可以构建一个近乎。构造函数的法子呢得以叫做工厂模式,因为构造函数的行事章程跟厂的办事法是平的。**工厂模式而是何许的为?这个呢不难理解,首先用原料,然后便是本着原材料进行加工,最后出厂,这便完成了。构造函数也是同一的措施,先创造一个靶,再上加属性和方法,最后回来。既说构造函数可以构建一个看似出来,这个拖欠怎么理解呢?很
easy,可以用工厂方式了解,
好像就一定给工厂面临的模具,也足以于模板,而目标就是零件、产品或被成品,类本身不有所实际的成效,仅仅只是用来养成品的,而目标才有实际的效益。**比如:var arr = new Array(1,2,3,4,5); Array
就是近似,arr 就是目标, 类 Array
没有实际的作用,就是之所以来存放数据的,而目标 arr
具有实际功能,比如:排序sort()、删除shift()、添加push()等。我们不容许这样写:new
arr(); 或 Array.push();,正确的写法:arr.push();。

 1 <script>
 2 function userInfo(name, qq){
 3 
 4     //1.原料 - 创建对象
 5     var obj = new Object();
 6 
 7     //2.加工 - 添加属性和方法
 8     obj.name = name;
 9     obj.qq = qq;
10     obj.showName = function (){
11         alert('我的名字叫:' + this.name);
12     };
13     obj.showQQ = function (){
14         alert('我的QQ是:' + this.qq);
15     };
16     //3.出厂 - 返回
17     return obj;
18 }
19 
20 var obj1 = userInfo('小白', '89898989');
21 obj1.showName();
22 obj1.showQQ();
23 
24 var obj2 = userInfo('小明', '12345678');
25 obj2.showName();
26 obj2.showQQ();
27 </script>

 

  这个函数的效力就是构建一个靶,userInfo()
就是构造函数,构造函数作为目标的类,提供一个模具,用来养用户对象,我们其后在动用时,只调用这个模板,就可无限创造用户对象。咱们且掌握,函数如果用于创造新的对象,就叫做对象的构造函数,我们尚掌握,在创立新对象时须使用
new 关键字,但是地方的代码,userInfo() 构造函数在采用时连无运用 new关
键字,这是为何呢?且看下文分解。

 

李四        74         
84          94

8、继承与原型链

  (1)、继承

  前边我们简要的游说罢连续是从已产生对象上,再累来一个初目标,**累就是在原有类的底子及,略发改,得到一个新的接近,不影响原有类的效用。**继承的实现有少数栽办法,最常用之饶是 call()
方法及原型实现连续。
下面看一个继续的实例:

 1 <script>
 2 function A(){
 3     this.abc = 12;
 4 }
 5 A.prototype.show = function (){
 6     alert(this.abc);
 7 };
 8 
 9 function B(){
10     A.call(this);
11 }
12 
13 for(var i in A.prototype){
14     B.prototype[i]=A.prototype[i];
15 }
16 
17 B.prototype.fn=function (){
18     alert('abc');
19 };
20 
21 var objB = new B();
22 alert(objB.abc);    //返回:12
23 objB.show();        //返回:12
24 objB.fn();            //返回:abc
25 
26 var objA = new A();
27 objA.fn();    //报错:A没有该方法
28 </script>

  上面的代码,B函数
继承了 A函数 的性,通过 call
方法,该措施发生一个效能,可以变更者函数在尽时中的 this 的针对,如果
B函数 中无应用 call,this 则指向 new B(),使用 call 后,this 则指向
A。方法继承 B.prototype = A.prototype;,A 的法勾勒以原型里,赋给
原型B,原型为是引用,将 A的原型 引用给 B的原型,就相当给 原型A 和 原型B
公用引用一个空中,所以 原型B 自己之不二法门,原型A 也堪用,给 原型B
添加一个术,也即是给 原型A 添加一个智。所以可以动用循环遍历 原型A
中之始末,再将这些内容予以给 原型B,这样 原型A 就从未 原型B
的点子了,也尽管是叫 B 再添加计,A 将未会见遭到震慑(objA.fn() 报错),B
不仅产生从父级继承来之方(objB.show()),还有自己的法(obj.fn())。

  (2)、原型链

  在 JS
中,每当定义一个靶(函数)时,对象吃还见面包含部分预定义的性质。其中函数对象的一个性能就是原型对象
prototype。
此地用小心:普通对象没
prototype,但来__proto__ 属性。**
原型对象的重中之重目标就用来后续。**

 1 <script>
 2 var A = function(name){
 3     this.name = name;
 4 };
 5 A.prototype.getName = function(){
 6     alert(this.name); 
 7 }
 8 var obj = new A('小明');
 9 obj.getName();    //返回:小明
10 
11 </script>

   上面的代码,通过叫
A.prototype 定义了一个函数对象的特性,再 new
出来的对象就蝉联了此特性。

  JS
以创建对象(不论是日常对象还是函数对象)时,都起一个吃做 __proto__
的停放属性,用于因于创造它的函数对象的原型对象
prototype。

 1 <script>
 2 var A = function(name){
 3     this.name = name;
 4 }
 5 A.prototype.getName = function(){
 6     alert(this.name); 
 7 }
 8 var obj = new A('小明');
 9 obj.getName();    //返回:小明
10 
11 alert(obj.__proto__ === A.prototype);    //返回:true
12 </script>

  同样,A.prototype
对象也出 __proto__ 属性,它对创建它的函数对象(Object)的
prototype。

 1 <script>
 2 var A = function(name){
 3     this.name = name;
 4 }
 5 A.prototype.getName = function(){
 6     alert(this.name); 
 7 }
 8 var obj = new A('小明');
 9 obj.getName();        //返回:小明
10 
11 alert(A.prototype.__proto__ === Object.prototype);    //返回:true
12 </script>

  Object.prototype
对象为发生 __proto__ 属性,但它们比特殊,为 null。

 1 <script>
 2 var A = function(name){
 3     this.name = name;
 4 }
 5 A.prototype.getName = function(){
 6     alert(this.name); 
 7 }
 8 var obj = new A('小明');
 9 obj.getName();        //返回:小明
10 
11 alert(Object.prototype.__proto__);    //返回:null
12 </script>

  综上,我们把这由 __proto__ 串起来的截至
Object.prototype.__proto__ 为 null
的链就受做原型链。

  于 JS
中,可以简简单单的将值分为两种植类型,即原始值和目标值。每个对象都起一个内部属性
(prototype),通常称为原型。原型的价值好是一个目标,也堪是
null。如果他的值是一个靶,则这目标为必将生投机之原型,由于原型对象自我为是目标,而异自己的原型对象又好来自己之原型,这样便整合了千篇一律条链子,我们虽称为原型链。**
JS
引擎以造访对象的属性时,如果在目标自我吃从来不找到,则会失掉原型链中查找,如果找到,直接回值,如果周链都遍历且没有找到属性,则回
undefined。原型链一般实现吗一个链表,这样即使得遵循一定之次第来查找,如果目标没显式的扬言自己的
”__proto__”属性,那么这个值默认的装置为 Object.prototype,而当
Object.prototype 的 ”__proto__”属性值为
”null”时,则表明在原型链的收。**

 

 unionall

5、new 和 this

  (1)new

  new
关键字之用意,就是行构造函数,返回一个实例对象。
在押下例子:

<script>
var user = function (){
  this.name = '小明';
};

var info = new user();
alert(info.name);    //返回:小明
</script>

 

   上面实例通过 new 关键字,让构造函数 user
生产一个实例对象,保存于变量 info 中,这个新创建的实例对象,从构造函数
user 继承了 name 属性。在 new 命令执行时,构造函数内部的
this,就意味着了初生产的实例对象,this.name 表示实例有一个 name
属性,他的值是小明。

  下 new
命令时,根据需要,构造函数也得以承受参数。

1 <script>
2 var user = function (n){
3   this.name = n;
4 };
5 
6 var info = new user('小明');
7 alert(info.name);    //返回:小明
8 </script>

 

  new
命令自己即得实施实施构造函数,所以后面的构造函数可以带括号,也可免带括号,下面两实行代码是相等价格的。

var info = new user;
var info = new user();

  那要无采用 new
命令,直接调用构造函数会什么呢?这种情况下,构造函数就改为了常备函数,并无会见养实例对象,this
这时候就代表全局对象。

1 <script>
2 var user = function (n){
3   this.name = n;
4 };
5 alert(this.name);    //返回:小明
6 
7 var info = user('小明');
8 alert(info.name);    //报错
9 </script>

  上面实例中,调用
user 构造函数时,没有动 new 命令,结果 name
变成了全局变量,而变量 info 就变成了
undefined,报错:无法读取未定义的性质 ‘name’。动用 new
命令时,他继止的函数调用就非是正规的调用,而是给 new
命令控制了,内部的流程是,先创造一个缺损对象,赋值给函数内部的 this
关键字,this 就对准一个新创造的空对象,所有对 this
的操作,都见面生在斯拖欠对象上,构造函数之所以受”构造函数”,就是说是函数的目的,可以操作
this 对象,将其布局为要之旗帜。
下我们看一下 new
和函数。

1 <script>
2 var user = function (){
3 //function = user(){
4     alert(this);
5 }
6 user();    //返回:Window
7 new user();//返回:Object
8 </script>

 

  通过者实例,可以看,于调用函数时,前边加个
new,构造函数内部的 this 就不是凭于 window
了,而是指于一个新创造出来的空白对象。

  说了这般多,那为什么我们第四回的构造函数,在采用的时节从不加
new
关键字呢,因为我们一齐是仍工厂模式,也就是构造函数的结构一直编写的,我们的步调都完结了
new 关键字之使命,也就是是管本来 new
需要做的转业,我们都举行了,所以就是富余 new
了。那这样怎么不是召开了众随便用功,写了无必要之代码,浪费资源,那得是了,这为是构造函数的一个有点问题,咱俩当生同样章节又举行具体分析。

  (2)、this

  this
翻译啊华语即是随即,这个,表示对。之前我们涉了,this
指向函数执行时之当前目标。
那么我们先来探望函数调用,函数有四栽调用方式,每种方式的异方法,就在
this 的初始化。

  ①、作为一个函数调用

1 <script>
2 function show(a, b) {
3     return a * b;
4 }
5 alert(show(2, 3));    //返回:6
6 </script>

 

  实例中之函数不属其他对象,但是在 JS
中他老是默认的大局对象,在 HTML 中默认的全局对象是 HTML
页面本身,所以函数是属于 HTML
页面,在浏览器被的页面对象是浏览器窗口(window
对象),所以该函数会自动成为 window 对象的函数。

1 <script>
2 function show(a, b) {
3     return a * b;
4 }
5 alert(show(2, 3));    //返回:6
6 alert(window.show(2, 3));//返回:6
7 </script>

  上面代码中,可以看来,show()
和 window.show() 是等价的。这是调用 JS
函数最常用之主意,但切莫是尽善尽美的编程习惯,因为全局变量,方法或者函数容易招命名冲突的
Bug。

  当函数没有被自己的对象调用时,this
的价就会见成为全局对象。

1 <script>
2 function show() {
3     return this;
4 }
5 alert(show());    //返回:[object Window]
6 </script>

  大局对象就是 window
对象,函数作为全局对象目标调用,this
的值也会化全局对象,
这里需要顾,使用 window
对象作为一个变量容易造成程序崩溃。

  ②、函数作为艺术调用

 1 <script>
 2 var user = {
 3     name : '小明',
 4     qq : 12345678,
 5     info : function (){
 6         return this.name + 'QQ是:' + this.qq;
 7     }
 8 }
 9 alert(user.info());
10 </script>

  每当 JS
中可拿函数定义也目标的法门,
方实例创建了一个靶
user,对象有两个属性(name和qq),及一个法
info,该方法是一个函数,函数属于对象,user 是函数的主人,this 对象有
JS 代码,实例中 this 的价为 user 对象,看下示例:

 1 <script>
 2 var user = {
 3     name : '小明',
 4     qq : 12345678,
 5     info : function (){
 6         return this;
 7     }
 8 }
 9 alert(user.info());    //返回:[object Object]
10 </script>

  函数作为对象方法调用,this
就对准对象自我。

  ③、使用构造函数调用函数

  设函数调用前下了
new关键字,就是调用了构造函数。

 1 <script>
 2 function user(n, q){
 3     this.name = n;
 4     this.qq  = q;
 5 }
 6 
 7 var info = new user('小明', 12345678);
 8 alert(info.name);    //返回:小明
 9 alert(info.qq);        //返回:12345678
10 </script>

  及时看起就如创建了初的函数,但实质上 JS
函数是新创造的对象,构造函数的调用就会见创一个初的目标,新对象见面继续构造函数的特性与措施。构造函数中之
this 并无外的价,this 的价在函数调用时实例化对象(new
object)时创造,也即是借助为一个新创建的空对象。

  ④、作为艺术函数调用函数

  每当 JS
中,函数是目标,对象来他的性质和措施。call() 和 apply()
是预定义的函数方法,这简单单艺术可用以调用函数,而且这点儿只方式的首先只参数还必为对象自我。

 1 <script>
 2 function show(a, b) {
 3     return a * b;
 4 }
 5 var x = show.call(show, 2, 3);
 6 alert(x);    //返回:6
 7 
 8 function shows(a, b) {
 9     return a * b;
10 }
11 var arr = [2,3];
12 var y = shows.apply(shows, arr);
13 var y1 = shows.call(shows, arr);
14 alert(y);    //返回:6
15 alert(y1);    //返回:NaN
16 </script>

  上面代码中的点滴单办法还应用了目标自我作为作为第一独参数,彼此的界别在:apply()方法传入的凡一个参数数组,也尽管是将大半个参数组合称为一个数组传入,而call()方法虽然当call的参数传入(从第二只参数开始),不克传回一个参数数组。

  由此 call() 或 apply() 方法好设置 this 的值,
且作为都是对象的初章程调用。
以底下用到的下,我们又具体分析。

  this
就是用来因为函数执行时之脚下目标,下面又拘留一个实例:

 1 <body>
 2 <div id="div1"></div>
 3 <script>
 4 var oDiv = document.getElementById('div1');
 5 //给一个对象添加事件,本质上是给这个对象添加方法。
 6 oDiv.onclick = function (){
 7     alert(this);    //this就是oDiv
 8 };
 9 
10 var arr = [1,2,3,4,5];
11 //给数组添加属性
12 arr.a = 12;
13 //给数组添加方法
14 arr.show = function (){
15     alert(this.a);    //this就是arr
16 };
17 arr.show();    //返回:12
18 
19 
20 function shows(){
21     alert(this);    //this就是window
22 }
23 
24 //全局函数是属于window的。
25 //所以写一个全局函数shows和给window加一个shows方法是一样的。
26 window.shows = function (){
27     alert(this);
28 };
29 shows();    //返回:[object Window]
30 </script>
31 </body>

   上面的代码,this
就意味着着时的函数(方法)属于哪个,如果是一个风波措施,this
就是当前发事件的靶子,如果是一个数组方法,this
就是数组对象,全局的计是属于 window 的,所以 this 指向
window。

 

PIVOT的貌似语法是:PIVOT(聚合函数(列) FOR 列 in (…) )AS
P

6、原型

  前面我们说过构造函数在动时没有加
new,这不得不算一个略带问题,没有加我们好吃加上,无伤大雅,但实质上他还存在着一个重新严重的题材,那就算是函数重复定义。

 1 <script>
 2 function userInfo(name, qq){
 3 
 4     //1.原料 - 创建对象
 5     var obj = new Object();
 6 
 7     //2.加工 - 添加属性和方法
 8     obj.name = name;
 9     obj.qq = qq;
10     obj.showName = function (){
11         alert('我的名字叫:'+this.name);
12     };
13     obj.showQQ = function (){
14         alert('我的QQ是:'+this.qq);
15     };
16     //3.出厂 - 返回
17     return obj;
18 }
19 
20 //1.没有new。
21 var obj1 = userInfo('小白', '89898989');
22 var obj2 = userInfo('小明', '1234567');
23 
24 //调用的showName返回的函数都是相同的。
25 alert(obj1.showName);
26 alert(obj2.showName);
27 
28 //2.函数重复。
29 alert(obj1.showName == obj2.showName);    //返回:false
30 </script>

  通过者的代码,我们好观看,弹有立刻半单对象的 showName,调用的 showName
返回的函数是一样的,他们新创造目标所使用的点子都是一致的,尽管就点儿单函数增长之是同等的,但骨子里他们连无是一个物,我们将
对象1 与 对象2 做顶比较,结果返回
false。这时候就牵动了一个相对严重的题目,一个网站中也未可能只有 2
个用户,比如有 1 万单用户对象,那么即使会见发 1 万 showName 同 showQQ
方法,每一个靶还发出温馨的函数,但明确即刻半个函数都是一样的,结果却并非如此。这样即便挺浪费系统资源,而且性能低,可能还会见起一些意想不到的问题。
该怎么化解者问题吗?方法也死简短,就是下原型。

  (1)、什么是原型

  JS
对象还发一个
事先我们没讲了之习性,即 prototype
属性,该属性让咱们出能力向目标上加属性和办法,包括
String对象、Array对象、Number对象、Date对象、Boolean对象,Math对象
并无像 String 和 Date 那样是目标的类似,因此无构造函数
Math(),该目标只是用于实践数学任务。

  怀有 JS
的函数都起一个prototype属性,这个特性引用了一个对象,即原型对象,也简称原型。这个函数包括构造函数和普通函数,
我们讲的再多是构造函数的原型,但是也非克否认普通函数也是来原型的。

  以拘留实例之前,我们先行来拘禁几单稍物:typeof运算符、constructor属性、instanceof运算符。

  typeof
大家都如数家珍,JS
中判断一个变量的数据类型就见面就此到 typeof 运算符,返回结果吗 JS
基本的数据类型,包括
number、string、boolean、object、function、undefined,语法:typeof
obj。

  constructor 属性返回所有 JS
变量的构造函数,typeof 无法判断 Array对象 和 Date对象 的门类,因为还回去
object,所以我们得采用 constructor
属性来查看对象是否为数组或者日期,语法:obj.constructor。

 1 <script>
 2 var arr = [1,2,3,4,5];
 3 function isArray(obj) {
 4     return arr.constructor.toString().indexOf("Array") > -1;
 5 }
 6 alert(isArray(arr));    //返回:ture
 7 
 8 var d = new Date();
 9 function isDate(obj) {
10     return d.constructor.toString().indexOf("Date") > -1;
11 }
12 alert(isDate(d));    //返回:ture
13 </script>

   这里要留意,constructor
只能针对都发变量进行判定,对于不声明的变量进行判定会报错,而 typeof
则只是对无声明变量进行判断(返回 undefined)。

  instanceof
这东西比高档,可用以判断一个对象是不是是某一样种多少类,查看对象是不是是有类的实例,返回值为
boolean 类型。另外,更要之一些凡是 instanceof
还可以以持续关系着之所以来判断一个实例是否属他的父类型,语法:a instanceof
b。

 1 <script>
 2 // 判断 a 是否是 A 类的实例 , 并且是否是其父类型的实例
 3 function A(){} 
 4 function B(){} 
 5 B.prototype = new A();    //JS原型继承
 6 
 7 var a = new B();
 8 alert(a instanceof A);    //返回:true
 9 alert(a instanceof B);    //返回:true 
10 </script>

   点的实例中判断了相同重叠继承关系遭遇之父类,在差不多叠继承关系被,instanceof
运算符同样适用。

  下面我们尽管来探寻常函数的原型:

1 <script>
2 function A(){}
3 alert(A.prototype instanceof Object);    //返回:true
4 </script>

  上面代码中
A 是一个日常的函数,我们看清函数 A 的原型是否是目标,结果返回
true。

  说了如此多,原型到底是独什么东西,说简练点原型就是是往类的面长方法,类似于class,修改外得影响平等近乎元素。原型就是是当早就发出对象吃加入自己之习性与办法,原型修改就起对象的震慑,prototype
属性可返回对象类型原型的援,如果目标创建于改原型之前,那么该目标非会见持有修改后的原型方法,就是说原型链的改观,不会见潜移默化前起的靶子。
关于原型链的学问,下面我们在出口继承时,再开分析。

  下面我们透过实例的方法,进一步的知情原型。

  实例:给数组添加方法

 1 <script>
 2 var arr1 = new Array(2,8,8);
 3 var arr2 = new Array(5,5,10);
 4 
 5 arr1.sum = function (){
 6     var result = 0;
 7     for(var i=0; i<this.length; i++){
 8         result += this[i];
 9     }
10     return result;
11 };
12 
13 alert(arr1.sum());  //返回:18
14 alert(arr2.sum());  //报错:arr2没有sum方法
15 </script>

  上面的实例只让
数组1 添加了 sum 方法,这虽象是于行间样式,只吃 arr1 设置了,所以 arr2
肯定会报错,这个并不难理解。

  实例:给原型添加方法

 1 <script>
 2 var arr1 = new Array(2,8,8);
 3 var arr2 = new Array(5,5,10);
 4 
 5 Array.prototype.sum = function (){
 6     var result = 0;
 7     for(var i=0; i<this.length; i++){
 8         result += this[i];
 9     }
10     return result;
11 };
12 
13 alert(arr1.sum());    //返回:18
14 alert(arr2.sum());    //返回:20
15 </script>

  通过上面的实例,我们得望,通过原型
prototype 给 Array 这个看似添加一个 sum 方法,就类似于
class,一不成可以安装同一组元素,那么具有的 Array 类都富有这个法子,arr1
返回结果也 18,而 arr2 在给定了原型之后,也归了科学的盘算结果
20。

  (2)、解决历史遗留问题

  现在咱们不怕得运用原型,来化解没有
new 和函数重复定义之问题了。

 1 <script>
 2 function UserInfo(name, qq){
 3 
 4     //1.原料 - 创建对象
 5     //var obj = new Object();
 6 
 7     //加了new之后,系统(浏览器)会自动替你声明一个变量:
 8     //var this = new Object();
 9 
10     //2.加工 - 添加属性和方法
11     /*
12     obj.name = name;
13     obj.qq = qq;
14     obj.showName = function (){
15         alert('我的名字叫:'+this.name);
16     };
17     obj.showQQ = function (){
18         alert('我的QQ是:'+this.qq);
19     };
20     */
21     this.name = name;
22     this.qq = qq;
23 
24     //3.出厂 - 返回
25     //return obj;
26 
27     //系统也会自动替你返回:
28     //return this;
29 }
30 
31 //2.函数重复的解决:userInfo给类加原型。
32 UserInfo.prototype.showName = function (){
33     alert('我的名字叫:' + this.name);
34 };
35 
36 UserInfo.prototype.showQQ = function (){
37     alert('我的QQ是:' + this.qq);
38 };
39 
40 
41 //1.加上没有new。
42 var obj1 = new UserInfo('小白', '89898989');
43 var obj2 = new UserInfo('小明', '1234567');
44 
45 obj1.showName();
46 obj1.showQQ();
47 obj2.showName();
48 obj2.showQQ();
49 
50 //加了原型之后
51 alert(obj1.showName == obj2.showName);    //返回:true
52 </script>

 

  上面的代码看在发接触复杂,我们把未必要的简练,如下:

 1 <script>
 2 function UserInfo(name, qq){
 3     this.name = name;
 4     this.qq = qq;
 5 }
 6 
 7 UserInfo.prototype.showName = function (){
 8     alert('我的名字叫:' + this.name);
 9 };
10 UserInfo.prototype.showQQ = function (){
11     alert('我的QQ是:' + this.qq);
12 };
13 
14 var obj1 = new UserInfo('小白', '89898989');
15 var obj2 = new UserInfo('小明', '1234567');
16 
17 obj1.showName();
18 obj1.showQQ();
19 obj2.showName();
20 obj2.showQQ();
21 
22 alert(obj1.showName == obj2.showName);    //返回:true
23 </script>

  现在代码是免是于头的榜样,简洁了过多,new
关键字为应用了,而且每个对象还是当的。通过上面的实例,我们好观看,再次添加 new
之后,使用就便宜了无数,代码明显滑坡了,因为于加以了 new
之后,系统为不怕是浏览器自动为公做简单项事,这就算是 new
的重任,第一码事是给而创造了一个空手对象,也就算是为而声明了一个变量:var
this = new Object();,第二桩事就是是再次领取你归这个目标:return
this;,
这里需要小心,在前头我们也提了,于调用函数的时节,前边加个 new,构造函数内部的
this 就无是据于 window
了,而是指于一个初创建出来的空对象。

  这种办法就是流行的面向对象编写方式,即混合方式构造函数,混合的构造函数/原型方式(Mixed Constructor
Function/Prototype Method),他的基准是:用构造函数加属性,用原型加计,也就是是因此构造函数定义对象的持有非函数属性,用原型方式定义对象的函数方法。用原型的意图,就是者目标的装有实例共享原型定义的数额与(对象)引用,防止重复创建函数,浪费内存。原型中定义的拥有函数和援的目标都止开创同坏,构造函数中的方法则会趁实例的缔造重复创建(如果生对象或方式的说话)。这里用专注,不管在原型中要么构造函数中,属性(值)都非共享,构造函数中的特性和章程还无共享,原型中属性不共享,但是对象同法共享。所以创建类的顶好方式就是故构造函数定义属性,用原型定义方法。
采取该方法,类名的首字母要大写,这也是同种植对象命名的正统。

 

 max(case课程when’数学’then分数else0end)数学,

9、JSON 的面向对象

  JSON 的面向对象,就是拿措施包含在一个 JSON
中,在单独不过发生一个靶时采用,整个程序只生一个对象,写起比较简单,但是非吻合多个对象。这种艺术吧让名命名空间,所谓命名空间,就是将多 JSON
用附加属性的计创造,然后每个里边都有和好的艺术,这种措施主要用来分类,使用方便,避免冲突。就一定给把同类措施归纳在共同,既可以不冲突,而且找起来方便。

 1 <script>
 2 //创建一个空的json
 3 var json = {};
 4 
 5 //现在就有了3个空的json
 6 json.a = {};
 7 json.b = {};
 8 json.c = {};
 9 
10 //现在3个json里边各有一个getUser函数,而且各不相同。
11 //在JS中,如果是相同命名的函数就会产生冲突,相互覆盖。
12 //但是这3个json不会相互冲突,相互覆盖。
13 json.a.getUser = function (){
14     alert('a');
15 };
16 json.b.getUser = function (){
17     alert('b');
18 };
19 json.c.getUser = function (){
20     alert('c');
21 };
22 json.a.getUser();    //返回:a
23 json.b.getUser();    //返回:b
24 json.c.getUser();    //返回:c
25 </script>

 

(select*fromtb pivot(max(分数)for课程in(语文,数学,物理))a)m,

7、面向对象实例

  一般性我们以形容序时,都以的凡面向过程,即如果呈现出什么效果,基于这样的法力,一步步编实现力量的代码,通下我们即便把面向过程的次第,改写成面向对象的样式。面向过程的顺序写起相对好把,代码也于直观,易读性强,咱俩事先押一个面向过程的实例。

  实例:面向过程的抉择项卡

 1 <!DOCTYPE html>
 2 <html>
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>JavaScript实例</title>
 6 <style>
 7 #div1 input{background:white;}
 8 #div1 input.active{background:green;color:white;}
 9 #div1 div{
10     width:200px;
11     height:200px;
12     background:#ccc;
13     display:none;
14 }
15 </style>
16 <script>
17 window.onload = function (){
18     //1、获取所需元素。
19     var oDiv = document.getElementById('div1');
20     var oBtn = oDiv.getElementsByTagName('input');
21     var aDiv = oDiv.getElementsByTagName('div');
22     
23     //2、循环遍历所有按钮。
24     for(var i=0; i<oBtn.length; i++){
25         //5、给按钮定义index属性,当前按钮的索引号为按钮的索引号i
26         oBtn[i].index = i;
27         //3、给当前按钮添加点击事件。
28         oBtn[i].onclick = function (){
29            //4、再循环所有按钮,清空当前按钮的class属性,并将当前内容的样式设置为隐藏
30            //在执行清空和设置之前,需要给当前按钮定义一个索引
31            //这一步的目的:主要就是实现切换效果,点击下一个按钮时,当前按钮失去焦点,内容失去焦点
32              for(var i=0; i<oBtn.length; i++){
33                 oBtn[i].className = '';
34                 aDiv[i].style.display = 'none';
35             }
36             //6、最后给当前按钮class属性,再设置当前展示内容的样式为显示
37             this.className = 'active';
38             aDiv[this.index].style.display = 'block';
39        };
40     }
41 };
42 </script>
43 </head>
44 <body>
45 <div id="div1">
46     <input class="active" type="button" value="新闻">
47     <input type="button" value="热点">
48     <input type="button" value="推荐">
49     <div style="display:block;">天气预报</div>
50     <div>历史实事</div>
51     <div>人文地理</div>
52 </div>
53 </body>
54 </html>

 

  这样一个简的力量,谁还好开的出来,那若怎么形容成面向对象的样式也,我们先来拘禁代码,再举行分析。

  实例:面向对象的选料项卡

 1 <!DOCTYPE html>
 2 <html>
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>JavaScript实例</title>
 6 <style>
 7 #div1 input{background:white;}
 8 #div1 input.active{background:green;color:white;}
 9 #div1 div{
10     width:200px;
11     height:200px;
12     background:#ccc;
13     display:none;
14 }
15 </style>
16 <script>
17 window.onload = function(){
18     new TabShow('div1');
19 };
20 
21 function TabShow(id){
22     var _this = this;
23     var oDiv = document.getElementById(id);
24     this.oBtn = oDiv.getElementsByTagName('input');
25     this.aDiv = oDiv.getElementsByTagName('div');
26     for(var i=0; i<this.oBtn.length; i++){
27         this.oBtn[i].index = i;
28         this.oBtn[i].onclick = function (){
29             _this.fnClick(this);
30         };
31     }
32 }
33 
34 TabShow.prototype.fnClick = function (oBtn){
35     for(var i=0; i<this.oBtn.length; i++){
36         this.oBtn[i].className = '';
37         this.aDiv[i].style.display = 'none';
38     }
39     oBtn.className = 'active';
40     this.aDiv[oBtn.index].style.display = 'block';
41 };
42 </script>
43 </head>
44 <body>
45 <div id="div1">
46     <input class="active" type="button" value="新闻">
47     <input type="button" value="热点">
48     <input type="button" value="推荐">
49     <div style="display:block;">天气预报</div>
50     <div>历史实事</div>
51     <div>人文地理</div>
52 </div>
53 </body>
54 </html>

   拿面向过程的先后,改写成面向对象的款型,原则就是是免可知起套数法函数,但好来全局变量,其过程是事先拿
onload
改也构造函数,再将全局变量改也性,函数改吗艺术,这就算是面向对象的思想,所以率先步就是是管嵌套函数单独出来,当函数单独出去下,onload
中定义之变量在点击函数着即会见报错,onload
也一定给一个构造函数,初始化整个程序,所以重复针对 onload
函数作出有改,让他初始化这个目标,然后就是补加属性和道,
我们说变量就是性,函数就是方,所以这里也不过是反所属关系。**这个**过程遭到最好要小心的凡 this
的针对性问题,通过闭包传递 this,以及函数传参,把对象作为参数传递。之前的
this 都是凭借于当前有事件的对象,将函数改也计后,
我们被这个方法添加的是按钮点击事件,所以这
this 就对这按钮,本应有是 this 是恃于新创建的对象,这就是得换
this 的针对性 var _this = this;。**
TabShow 函数就是 onload
函数的改造,fnClick
方法是率先步单独出去的函数,最后为变成了选项卡函数 (TabShow函数)
的点子。**

 

whereID=object_id(‘tb’)andNamenotin(‘姓名’)

1、什么是面向对象编程

  倘懂面向对象,得先搞明白什么是目标,先是要肯定一点这里所说的目标,不是活受到之干男女朋友对象,面向对象就是面向着对象,换在代码中,就是千篇一律段子代码相中了别样一样截代码,自是夜以继日底含情脉脉的面向着就等同段代码,这便称面向对象,谁设如此被丁解释,那笑话不过即使发生大了,但是得将男朋友或女对象视为一个靶,之前我们为大概的牵线了对象,即好把一个丁即一个目标,对象来他的性与道,属性如:性别、身高、体重、籍贯等,方法有动、跑、跳等。那么我们即便可由点滴上面了解对象:

  (1)、从目标自我理解,对象就是单个实物的肤浅。

  一本书、一辆车、一华电视机可以为视为对象,一摆设网页、一个数据库、一个服务器请求也堪于视为一个靶,当实物被架空成靶子,那么实物之间的关系虽变成了对象期间的涉,从而就好套现实情况,针对”对象”进行编程。

  (2)、从目标的性质理解,对象是一个容器,包含属性和方式。

  所谓属性,就是目标的状态,所谓方法,就是目标的所作所为(完成某种任务),比如,我们好把动物抽象为对象,属性记录具体是啦一样种动物,方法表示动物的作为,比如:捕猎、奔跑、攻击、飞、爬、休息相当。

  圆来讲,对象是一个整机,对外提供一些操作,比如电视,我们连无打听其中间整合及工作原理,但是我们都见面采用,对于电视来说,只要用好按钮,会操作,这个电路那个元件怎么工作,跟咱们没关系关系,只要电视能正常运作就好了,我们设了解每个按钮是干嘛的,就好运用这些效应,这便是面向对象。再比如取时间
Date,通过不同的性质我们可以得到到不同之时刻,比如年份月份星期,我们并不知道他现实是怎落实之,但是都懂得用谁属性可以赢得到所待的,这虽是面向对象。

  那究竟什么是面向对象?简单说就是是以未了解中原理的情况下,会使用其效用。就是动对象时,只关心对象提供的作用,不关注该里面细节。典型的采取实例就是
jQuery。

  面向对象是同样种通用的思索,并非只有编程中能够因此,任何工作还可以应用,生活遭充斥了面向对象的考虑,只是我们不直接让面向对象,而是为一些别的啊。按部就班你错过用餐,你虽报告厨师来平等客红烧肉,然后就好以下来当着吃了,你切莫可能为厨师说若把肉切成方的或到之,要先期放盐,再放开酱油,还要加红糖,加冰糖也得,谁真的要这样,厨师非得和你着急,他是大师傅还是你是大师傅,你若把想吃的报告他,你莫用去管他是怎开的,他自会善吃您捧上,这便是在备受突出的面向对象的构思。

  虽然不同让人情的面向对象编程语言,但是 JS
也发生不行强的面向对象编程能力,
属下就是具体分析以下什么是 JS
面向对象编程。

  面向对象编程(Object Oriented
Programming,缩写为 OOP)是现阶段主流的编程范式,所谓范式,就是称某一样种植级别之涉模式的集纳。他的核心思想是将真正世界面临各种繁复的涉及,抽象为一个个对象,然后由对象中的分工与协作,完成对实际世界的模拟。**
面向对象编程的顺序就算是副某平等种植级别的涉及模式之汇,是一律雨后春笋对象的咬合,每一个靶还是职能核心,具有明确分工,可以完成接受信息、处理多少、发出消息相当任务。**因此,面向对象编程具有灵活性、代码的不过重用性、模块性等特征,并且爱保障与支付,非常适合多总人口搭档之大型项目,而当平时项目受到貌似不常使用。

  面向对象编程(**OOP**)的特点:

  (1)、抽象:抓住核心问题

  所谓泛,先来探百度对于肤浅的诠释:抽象是自从许多的事物中抽取产生一道之、本质性的特点,而舍弃其非本质之特性。例如苹果、香蕉、鸭梨、葡萄、桃子等,它们一起之特色即是水果。得出水果概念的长河,就是一个华而不实的长河。要抽象,就亟须进行比,没有比较就无法找到以真相上一道的片。共同特性是凭那些能够拿同类似东西和另外类似东西区分开来之风味,这些有着区分作用的表征又如本质特征。因此抽取物之联手特点就是是抽取物的本质特征,舍弃非本质的特征。所以抽象的长河吧是一个推的过程。在架空时,同与差,决定给由什么角度达来抽象。抽象的角度取决于分析问题之目的。

  每当 JS
中,抽象的基本就是抽,就是引发并特点,抓住核心的题目。
依照说人,有多风味,比如姓名、性别、籍贯、出生日期、身高、体重、血型、家庭住址、父母是谁、孩子吃什么当,如果一个局要树立职工档案,不容许将每个特征都注明,需要吸引一些要害的性状,比如:姓名、性别、部门、职位,或者另行长入职日期就寿终正寝了。如果需要注册一个婚恋网站,那就早晚即便不是索要员工档案中注明的那些特点了,要有的准:性别、年龄、身高、体形、星座、有车否、有房否、工作、收入、家庭状况等。就是管同看似东西主要的特性、跟问题相关的特色抽取出来。这便是面向对象编程的空洞。

  (2)、封装:不考虑其中贯彻,只考虑功能应用

  何也包装,就好比同样华电视机,我们会望电视,比如外观、颜色相当,但是看不到里面的结合,我们也非用掌握里面是啊坏,依然可正常使用,除非这货非常了,这里面的物就是包裹。JS
就是休考虑中的落实,只考虑功能的行使,就比如用 jQuery 一样,jQuery
就是本着 JS 的包装,我们运用 jQuery 的作用,能不负众望及 JS
相同之功能,并且还比使用 JS 更有利。

  (3)、继承:从已出对象及,继承来新的对象

  所谓继承,也堪叫做遗传,浅明了就是是上下能够干的事男女呢克干,比如用,睡觉。在 JS 中,比如有一个目标 A,A
中出一些效,现在自 A 中延续来一个对象 B,这个目标 B 就拥有对象 A
的有所机能。

  还有平等种植情况是**大多重继承,好比一个孩可出多独大,显然这是匪可能的事,但是在先后中及时是实用之,论来同样类盒子,盒子有一个特征可以据此来装东西,还有一样看似汽车,汽车的特点就是是会见跑,有车轮,这时候就好多更继承,继承来任何一样近乎集装箱货车,他特征既可以装作东西而见面蒸发,有车轮。**

  (4)、多态

  多态,顾名思义就是又状态,在面向对象语言中,接口的多种不同的落实方式就是为多态。多态在
JS 中不是那显著,但是对强语言比较起因此,比如 Java,C++。对于 JS
这种弱语言,意义并无殊。

 

(select姓名,sum(分数)总分,cast(avg(分数*1.0)asdecimal(18,2))平均分

3、面向对象编程

  我们经过实例的措施,为目标上加属性和方,来了解对象的结缘及面向对象。

  (1)、实例:**吃目标上加属性**

 1 <script>
 2 var a = 2;
 3 alert(a);    //返回:2
 4 
 5 var arr = [5,6,7,8,9];
 6 //给数组定义一个属性a,等于2。
 7 arr.a = 2;
 8 alert(arr.a);    //返回:2
 9 arr.a++;
10 alert(arr.a);    //返回:3
11 </script>

 

  通过者的实例,我们可以看出,变量和性质就是同一的,变量可以开的从,属性为足以做,属性可以举行的行,变量也得举行。他们的别就是在于,变量是擅自之,不属另外对象,而性不是不管三七二十一的,他是属一个目标的,便比如例子中之对象
a,他是属于数组 arr 的,在使用的时段便形容为 arr.a。我们可以叫其它对象定义属性,比如让 DIV
定义一个属性用于索引:oDiv[i].index = i。

  (2)、**实例:给目标上加方**

 1 <script>
 2 function a(){
 3     alert('abc');    //返回:abc
 4 }
 5 
 6 var arr = [5,6,7,8,9];
 7 //给函数添加一个a函数的方法
 8 arr.a = function (){
 9     alert('abc');    //返回:abc
10 };
11 a();
12 arr.a();
13 </script>

  通过地方的实例,可以看出,a
函数也是任意的,而当这个 a 函数属于一个目标的下,这即是方法,是数组
arr 的 a 方法,也即是此目标的道。**所以**函数和道吧是如出一辙的,函数可以举行的事,方法就好开,他们的不同,也是在函数是任意之,而艺术是属于一个目标的。

  我们匪可知当系统对象吃擅自附加属性与法,否则会蒙已有些属性和道。按照实例中我们是以数组对象及附加属性和方法的,数组有异好之习性与办法,我们又让其附加属性和章程,就见面盖掉数组本身的性能和法,这一点消留意。

  (3)、实例:**创建对象**

1 <script>
2 var obj = new Object();
3 var d = new Date();
4 var arr = new Array();
5 alert(obj);    //返回:[object Object]
6 alert(d);    //返回当前时间
7 alert(arr);    //返回为空,空数组
8 </script>

  始建一个新对象,可以 new 一个 Object。object
是一个空白对象,只有系统自带的有非常微量的物,所以当促成面向对象的时光,就可以被
object
上加以方,加属性。这样可以极其要命限度的免与另外起冲突。

  (4)、实例:面向对象程序

 1 <script>
 2 //创建一个对象
 3 var obj = new Object();
 4 //可写为:var obj={};
 5 
 6 //给对象添加属性
 7 obj.name = '小白';
 8 obj.qq = '89898989';
 9 
10 //给对象添加方法
11 obj.showName = function (){
12     alert('我的名字叫:'+this.name);
13 };
14 obj.showQQ = function (){
15     alert('我的QQ是:'+this.qq);
16 };
17 obj.showName();    //返回:我的名字叫:小白
18 obj.showQQ();    //返回:我的QQ是:89898989
19 
20 //再创建一个对象
21 var obj2 = new Object();
22 
23 obj2.name = '小明';
24 obj2.qq = '12345678';
25 
26 obj2.showName = function (){
27     alert('我的名字叫:'+this.name);
28 };
29 obj2.showQQ = function (){
30     alert('我的QQ是:'+this.qq);
31 };
32 obj2.showName();    //返回:我的名字叫:小白
33 obj2.showQQ();        //返回:我的QQ是:12345678
34 </script>

  马上便是一个无限简便的面向对象编程,创建一个对象,给目标上加属性和办法,模拟现实情况,针对对象开展编程。夫微序运行是尚未呀问题,但是存在大严重的通病,一个网站遭遇无可能只有发生一个用户对象,可能有诸多个,不可能为每个用户还
new 一个
object。其实可以以那卷入为一个函数,然后重新调用,有微只用户,调用多少次,这样的函数就吃称构造函数。

 

)

whereName!=’姓名’andID=object_id(‘tb’)–表名tb,不带有列名为现名的旁列

select@sql=@sql+’,’+课程fromtbgroupby课程–变量多值赋值

李四       数学        84

orderby姓名,case课程when’语文’then1when’数学’then2when’物理’then3end

ifobject_id(‘tb’)isnotnulldroptabletb

2、使用SQL Server
2000动态SQL

declare@sqlvarchar(8000)

 unionall

–SQL
SERVER 2000静态SQL

fromsyscolumns

–使用stuff()

–c

select姓名,

 

select*fromtb

4、使用SQL Server
2005静态SQL

select姓名,课程,分数fromtb unpivot (分数for课程in([语文],[数学],[物理])) t

groupby姓名

星座 1 常青就是应这样开放  游玩测试:三国期谁是若尽好的小兄弟!!  汝不得不信的星辰座神秘星座 2

其次、行转列结果加上总分、平均分

set@sql=stuff(@sql,1,1,”)–去丢首个’,’

4、使用SQL Server
2005动态SQL

 

1、建立表格

set@sql=’select姓名’

go

from

张三       74         
83          93

fromtb

张三       语文 74

 select姓名,课程=’语文’,分数=语文fromtb

UNPIVOT(

set@sql=stuff(@sql,1,1,”)–去丢首独’,’

突出实例

select@sql=@sql+’,’+课程fromtbgroupby课程–变量多值赋值

select@sql=@sql+’,max(case课程when
”’+课程+”’ then分数else 0
end)[‘+课程+’]’

declare@sqlvarchar(500)

 


姓名       语文        数学        物理        总分        平均分

set@sql=@sql+’ from tb group
by姓名’

insertintotbvalues(‘张三’,’物理’,93)

 max(case课程when’语文’then分数else0end)语文,

declare@sqlnvarchar(4000)

(select姓名,sum(分数)总分,
cast(avg(分数*1.0)
as decimal(18,2))平均分from tb
group by姓名)
n

张三        74         
83          93          250         83.33

–SQL
SERVER 2000动态SQL,指科目不止语文、数学、物理就三流派科目。(以下同)

select*from

2、使用SQL Server
2000静态SQL

exec(@sql)

ifobject_id(‘tb’)isnotnulldroptabletb


张三       物理        93

from(selectdistinct课程fromtb)asa      

姓名       课程 分数

 

FOR
pivot_column

姓名       语文        数学        物理

insertintotbvalues(‘李四’,74,84,94)

 

go

)
t

 

张三       语文        74


一、行转列

set@sql=’select姓名,[课程],[分数] from
tb unpivot ([分数] for
[课程]
in(‘+@sql+’))b’

4、使用SQL Server
2005动态SQL

–SQL
SERVER 2005动态SQL

createtabletb(姓名varchar(10),课程varchar(10),分数int)

where
m.姓名=
n.姓名’

1、建立表格

姓名       语文        数学        物理

go

 

–-获得课程集合

set@sql=’select姓名,’+@sql+’ from tb group
by姓名’

–或使用isnull()

–SQL
SERVER 2000动态SQL。

go

insertintotbvalues(‘张三’,’数学’,83)

insertintotbvalues(‘李四’,’物理’,94)

–变量按sql语言顺序赋值

fromtb

–SQL
SERVER 2000静态SQL。

select*fromtb pivot(max(分数)for课程in(语文,数学,物理))a

where
m.姓名=
n.姓名’

李四       物理 94

orderbyColid


3、使用SQL Server
2000动态SQL

cast(avg(分数*1.0)asdecimal(18,2))平均分

3、使用SQL Server
2005静态SQL

select姓名,

 max(case课程when’物理’then分数else0end)物理

select*fromtb

姓名       课程       分数

PIVOT(

PIVOT用于将列值旋转也列名(即行转列),在SQL
Server 2000方可就此聚合函数配合CASE语句实现

set@sql=”  –初始化变量@sql

go

set@sql=’select * from
tb pivot (max(分数)
for课程in
(‘+@sql+’))a’

 

姓名       数学        物理        语文

declare@sqlvarchar(8000)

exec(@sql)

exec(@sql)

李四       数学 84

2、使用SQL Server
2000动态SQL

go

declare@sqlvarchar(8000)

 

table_source

set@sql=’select m.* ,
n.总分,n.平均分from

+quotename(Name,””)+’ , [分数] =
‘+quotename(Name)+’ from tb’

exec(@sql+’ order
by姓名’)

 

5、使用SQL
Server 2005动态SQL

sum(分数)总分,

李四       语文 74

IN()

set@sql=”  –初始化变量@sql

1、使用SQL Server
2000静态SQL


二、列转行

李四       物理        94

–SQL
SERVER 2005动态SQL

李四       语文        74

declare@sqlvarchar(8000)

exec(@sql)

createtabletb(姓名varchar(10),语文int,数学int,物理int)

 

聚合函数(value_column)

张三        74         
83          93

insertintotbvalues(‘李四’,’数学’,84)


张三       数学        83

exec(@sql)

整语法:

张三        83         
93          74

groupby姓名)n

欠文章经过自己整理所得,欢迎转载,转载时恳求加上本文地址;本文基于签署 2.5
中国次大陆许可协议宣布,请不演绎或用来生意目的,但是得保留本文的签字张志涛

IN()

orderbycolid


select@sql=isnull(@sql+’,’,”)+quotename(Name)

exec(@sql)

declare@sqlvarchar(8000)

set@sql=@sql+’,sum(分数)总分,cast(avg(分数*1.0)
as decimal(18,2))      平均分from tb
group by姓名’

 

 select姓名,课程=’数学’,分数=数学fromtb

set@sql=’select姓名’


 @sql+’)) b) m
,

FOR
pivot_column

from(selectdistinct课程fromtb)a

wherem.姓名=n.姓名

  

select@sql=isnull(@sql+’,’,”)+课程fromtbgroupby课程           

 

–同select
@sql = @sql + ‘,’+课程from
(select distinct课程from
tb)a

李四        74         
84          94          252         84.00

 

declare@sqlvarchar(500)

max(case课程when’语文’then分数else0end)语文,

select@sql=isnull(@sql+’,’,”)+课程fromtbgroupby课程

 

–调用系统表动态生态。

(

declare@sqlvarchar(8000)


exec(@sql)

table_source

select@sql=isnull(@sql+’,’,”)+’ max(case课程when
”’+课程+”’ then分数else 0
end) [‘+课程+’]’

value_column

)

瞩目:PIVOT、UNPIVOT是SQL Server
2005 的语法,使用需要修改数据库兼容级别
 在数据库属性->选项->兼容级别改也  
90

(select姓名,sum(分数)总分,
cast(avg(分数*1.0)
as decimal(18,2))平均分from tb
group by姓名)
n

set@sql=’select m.* ,
n.总分,n.平均分from

(select
* from (select * from tb) a pivot (max(分数)
for课程in
(‘+

set@sql=’select * from
tb pivot (max(分数)
for课程in
(‘+@sql+’))a’

insertintotbvalues(‘张三’,’语文’,74)

from(selectdistinct课程fromtb)a–同from
tb group by课程,默认按学科名为排序

select@sql=@sql+’,max(case课程when
”’+课程+”’ then分数else 0
end)[‘+课程+’]’

groupby姓名

 

(select
* from (select * from tb) a pivot (max(分数)
for课程in
(‘+@sql+’)) b) m
,

 

fromsyscolumns


max(case课程when’数学’then分数else0end)数学,

张三       数学 83

 select姓名,课程=’物理’,分数=物理fromtb

张三       物理 93

李四        74         
84          94

–以isnull(),变量先确定动态部分

 

完语法:

insertintotbvalues(‘张三’,74,83,93)

–或使用isnull()

fromtb

select@sql=isnull(@sql+’ union all
‘,”)+’
select姓名,
[课程]=’

UNPIVOT用于将列明转为列值(即列转行),在SQL Server 2000足就此UNION来落实


go


2、使用SQL Server
2000静态SQL

max(case课程when’物理’then分数else0end)物理,

–SQL
SERVER 2000动态SQL

李四        84         
94          74

–使用stuff()

insertintotbvalues(‘李四’,’语文’,74)

3、使用SQL Server
2005静态SQL

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图