一 概述
JavaScript数组同后端语言同样，具备它本身的数据结构，归根结底，这种数据结构，本质就是一种集合。
在后端语言中(如java,.net等)，数组是这样定义的：数组是用来存储相同数据类型的集合。这个定义，“相同数据类型”6个字限制了数据只能存储相同的数据类型，如int[]数组只能存储数字，而不能存储字符串，以下定义方式，是错误的，由于string
不属于整型
int[] arr = { 10, 20,"string" };
然而，在JavaScript中，数组的定义倒是很是宽松的，这也决定了其能存储一切数据的特色。JavaScript数组具备以下特色
特色1：存储相同基本数据类型的数据；
特色2：存储不一样基本数据类型的数据；
特色3：存储对象
这三个特色，咱们可归结为一句话：JavaScript存储一切对象，而不像后端语言那样，只能存储相同数据类型。除此以外，JavaScript数组还提供了不少丰富的操做方法。以下为经常使用的操做方法。
本篇文章将主要结合代码来论述JavaScript数组。
二 对数组的基本操做
（一）建立数组
第一种方式:构造函数方式
//第一种建立数组的方式:构造函数方式
var colors = new Array();//未知数组长度
//var colors = new Array(4);//已知数组长度
//var colors = new Array('green', 'yellow', 'white', 'red');//建立数组同时，给数组赋值
//var colors = Array();//在建立时，能够省略new关键字
第二种方式:字面量方式
//第二种建立数组方式：使用数组字面量
var colors = ['green', 'yellow', 'white', 'red'];
var name = [];//建立空数组
（二）访问数组
访问数组，经过数组的下标来访问
//建立数组
var colors = ['green', 'yellow', 'white', 'red'];
//输出索引值
for (var i = 0; i < colors.length; i++) {
alert(colors[i]);//green,yellow,white,red
}
提示：for...in...访问数组属性(索引)，而不是数组属性值
//建立数组
var colors = ['green', 'yellow', 'white', 'red'];
//输出数组索引
for (var propAttr in colors) {
alert(propAttr);//0,1,2,3
}
（三）为数组添加元素
第一种方式：栈方式(后进先出，从数组尾部加入数据)
//建立数组
var colors = ['green', 'yellow', 'white', 'red'];
//第一种方式：栈方式
colors.push("orange");
for (var i = 0; i < colors.length; i++) {
alert(colors[i]);//green,yellow,white,red,orange
}
第二种方式：队列方式(先进先出，从数组头部加入数据)
var colors = ['green', 'yellow', 'white', 'red'];
colors.unshift('orange');
for (var i = 0; i < colors.length; i++) {
alert(colors[i]);//orange,green,yellow,white,red
}
（四）移除数组元素
第一种方式:栈方式(后进先出，从数组尾部移除数据)
//建立数组
var colors = ['green', 'yellow', 'white', 'red'];
//从尾部弹出数据
colors.pop();
for (var i = 0; i < colors.length; i++) {
alert(colors[i]);//green,yellow,white
}
第二种方式：队列方式(先进先出，从数据头部移除数据)
//建立数组
var colors = ['green', 'yellow', 'white', 'red'];
//从头部移除数据
colors.shift();
for (var i = 0; i < colors.length; i++) {
alert(colors[i]);//yellow,white,red
}
第三种方式：length方式(借助length属性可访问性来操做)
//建立数组
var colors = ['green', 'yellow', 'white', 'red'];
//从尾部移除数据，与pop()同样
colors.length = 3;
for (var i = 0; i < colors.length; i++) {
alert(colors[i]);//green,yellow,white
}
三 数组方法
（一）检测方法
数组检测方式，可经过typeof,instranceof和Array.isArray()来检测。
（二）转换方法
全部对象都具备toLocaleString(),toString()和valueOf()三个方法，数组也如此。
1.toString()
toString()将数据的每一个属性值转化为对应的字符串，而后再输出转换后的字符串值。
var colors = ['red','green','yellow'];
alert(colors.toString());//red,green,yellow
而下列代码与如上代码是同样的，由于alert()接收的是字符串，因此会在后台调用toString()方法
var colors = ['red','green','yellow'];
alert(colors);//red,green,yellow
2.valueOf()
valueOf()方法同toString()方法同样，也是返回数组的字符串
var colors = ['red', 'green', 'yellow'];
alert(colors.valueOf());//red,green,yellow
3.toLocaleString()
toLocaleString()返回数组的字符串形式。
var colors = ['red', 'green', 'yellow'];
alert(colors.toLocaleString());//red,green,yellow
4 三者之间关系
关系1：当不显示指出调用哪一个方法时(toString(),toLocaleString()和valueOf())，默认调用每一个属性的toString()；
关系2：当显示地指出调用哪一个方法时，就调用每一个属性的该方法；
关系3：关于valueOf问题，暂留
var person1 = {
toString: function () {
return "Alan";
},
toLocaleString: function () {
return "Alan_beijing";
},
valueOf: function () {
return "valueOf1";
}
};
var person2 = {
toString: function () {
return "Alan1";
},
toLocaleString: function () {
return "Alan_beijing1";
}
}
var people = [person1, person2];
alert(people.toString());//Alan,Alan1
alert(people.toLocaleString());//Alan_beijing,Alan_beijing1
alert(people.valueOf());//Alan,Alan1
alert(people);//Alan,Alan1
（三）栈方法
栈是一种数据结构，其算法为:LIFO(Last input First out)后进先出，其两个核心方法为push()和pop();
1.push()
push()表示将数据压入栈中，且放在栈的最后位置，即从栈的尾部压入数据。对于数组，则在数组的尾部加入数据，操做的顺序为：先把数组length+1，再压入数据。
var arr = [10, 20, 30];
arr.push('新加入的数据');
alert(arr.toString());//10,20,30,新加入的数据
2.pop()
push()表示将数据从栈中弹出，且从栈的最后位置弹出。对于数组，则在数组的尾部弹出数据，操做的顺序为：先弹出数据，再数组length-1
var arr = [10, 20, 30];
arr.pop();
alert(arr.toString());//10,20
（四）队列
队列是一种数据结构，其算法为:FIFO(First input First out)后进先出，其两个核心方法为unshift()()和shift();
1.unshift()
unshift()表示从队列头部加入数据。对于数组，则从数组索引最小位置加入数据，操做顺序为：先将数length+1,再将当前数组属性值日后移动1个位置，最后将新数据添加到索引0处。
var arr = [10, 20, 30];
arr.unshift(40);
alert(arr.toString());//40,10,20,30
2.shift()
shift()表示从队列头部移除数据。对于数组，则从数组索引最小位置移除数据。
var arr = [20, 30];
arr.shift();
alert(arr.toString());//30
（五）排序方法
在js数组中，两个重要的重排序方法：reverse()和sort()
1.reverse()
reverse()，顾名思义，逆序方法。
var arr = [1,2,3,4,5];
alert(arr.reverse());//5,4,3,2,1
2.sort()
sort()是比较灵活的排序方法了，支持自定义排序规则，默认排序为升序
默认为升序
var arr = [3, 1, 2, 5, 4];
alert(arr.sort());//1,2,3,4,5
自定义排序规则
var arr = [3, 1, 2, 5, 4];
alert(arr.sort(Compare));//1,2,3,4,5
//自定义排序规则：正序
function Compare(value1, value2) {
if (value1 > value2) {
return 1;
} else if (value1 < value2) {
return -1;
} else {
return 0;
}
}
（六）位置方法
js数组提供了两个位置方法：indexof()和lastIndexOf()
indexOf()表示首次知足条件的位置;而lastIndexOf()则表示最后知足条件的位置
var arr = [20, 30,20,40,10];
alert(arr.indexOf(20)); //0
alert(arr.lastIndexOf(20));//2
（七）迭代方法
ECMAScript5提供了5个迭代方法：every(),filter(),forEach(),map()和some()
这个五个方法，均接收2个参数。
1.every()
对数组中的每项运行给定函数，若是该函数对每一项都返回ture，则返回true，不然返回false.
//every
var num = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var everyResult = num.every(function (item, index,array) {
return item>2
});
alert(everyResult);//fasle
2.some
对数组中的每项运行给定函数，若是该函数对任意一项返回ture，则返回true，不然返回false
//some
var num = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var someResult = num.some(function (item, index, array) {
return item > 2;
});
alert(someResult);//true
3.filter
对数组中的每项运行给定函数,返回该函数会返回true的项组成的数组
//filter
var num = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var filterResult = num.filter(function (item, index, array) {
return item > 2;
});
alert(filterResult);//3,4,5,4,3
4.map
对数组中的每项运行给定函数，返回每次函数调用的结果组成的数组
//map
var num = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var mapResult = num.map(function (item, index, array) {
return item * 2;
});
alert(mapResult);//2,4,6,8,10,8,6,4,2
5.forEach
对数组中的每项运行给定函数。注意，该方法没返回值
//forEach
num.forEach(function (item, index, array) {
//执行想要执行的操做
});
（八）求和方法
ECMAScript提供了2个缩减方法：reduce()和reduceRight()
reduce和reduceRight,至关于.net的斐波拉列数列，计算算法为：f(n)=f(n-1)+f(n-2);
1.reduce
reduce计算数组时，按照从左到右的顺序
var values = [1, 2, 3, 4, 5];
var sum = values.reduce(function (prev, cur, index, array) {
return prev + cur;
});
alert(sum);//15
2.reduceRight
reduceTight计算数组时，从右到左顺序
var values = [1, 2, 3, 4, 5];
var sum1 = values.reduceRight(function (prev, cur, index, array) {
return prev + cur;
});
alert(sum1);//15
(九)其余方法
ECMAScript为数组操做提供了不少方法，如concat()和slice()
1.concat()
concat()方法是将两个对象合并，从而生成新对象，合并同时，不会改变原来对象的值，只是作简单的拷贝
var color1 = ['red', 'green', 'yellow'];
var color2 = ['white', 'blue'];
//添加数组
var concatColor = color1.concat(color2);
alert(concatColor);//red,green,yellow,white,blue
//添加单个值
var concatSingelColor = color1.concat('orange');
alert(concatSingelColor);//red,green,yellow,orange
//不添加值，只是简单copy
var concatColor1 = color1.concat();
alert(concatColor1);//red,green,yellow
2.slice
slice()方法用于从目标数据中截取新数据，不会改变被截取对象的值。
var color1 = ['red', 'green', 'yellow'];
//不传递参数：表示截取整个数组
var color2 = color1.slice();
alert(color2);//red,green,yellow
//传递一个参数：表示从该位置处开始截取数据，直到数组最后一个数
var color3 = color1.slice(1);
alert(color3);//green,yellow
//传递2个参数：第一个参数表示从该位置开始截取，第二个参数减1表示所截数据的最后位置
var color4 = color1.slice(1, color1.length);
alert(color4);//green,yellow
在编程语言中，不管是面向过程的C,兼备面过程和对象的c++，仍是面向对象的编程语言，如java,.net,php等，函数均扮演着重要的角色。固然，在面向对象编程语言JavaScript中(严格来讲，JS属于弱面向对象编程语言)，函数(function)更扮演着极其重要的角色和占有极其重要的地位。在本篇文章中，不论述什么是JS，JS解决什么问题等之类问题，而是重点阐述JS中的函数(function)。
一 JavaScript函数
（一）何为函数
关于函数的定义，咱们先从两个角度来思考：数学角度和编程语言角度。
1.数学角度：在数学领域，关于“函数”二字，再熟悉不过，如三角函数，反三角函数，幂函数，对数函数，指数函数，微积分函数等；
2.编程角度：在编程领域，你们最熟悉且最早接触的应该是"Main函数"了，除此外，如日期函数(Date)，数学函数(Math)等，固然除了内置函数外，还包括用户自定义函数；
综合1，2点，能够将函数定义以下：
函数是解决某类问题的集合，是某类问题的高度抽象，它具备必定的通用性和复用性。
（二）定义函数
在Javascript中，存在三种经典的函数定义方式：函数声明式，函数表达式和函数构造式
1.函数声明式
1 //定义两个数相加函数
2 function AddNum(num1, num2) {
3 return num1 + num2;
4 }
注意：函数声明式，不能用匿名函数，以下方式定义错误的
1 function (num1, num2) {
2 return num1 + num2;
3 }
2.函数表达式
1 //定义两个数相加函数
2 var AddFun=function AddNum(num1, num2) {
3 return num1 + num2;
4 }
注意：函数表达式通常用匿名函数，由于调用时，不用函数名，所以，如上调用也可写成以下：
1 var AddFun = function(num1, num2) {
2 return num1 + num2;
3 }
3.函数构造式
1 var sum = new Function('num1', 'num2', 'return num1 + num2')
2 console.log(sum(10,20));//30
（三）函数调用
在JavaScript中，函数的调用采用“函数名(参数)”的格式来进行调用。
须要注意的是，JavaScript函数调用与后端语言函数调用(如java,.net等)存在细微差异，即JavaScript没有函数重载，参数的参数个数，由实参决定，而不是由形参决定。
1.声明式调用
调用方式一：通常调用
1 //定义两个数相加函数
2 function AddNum(num1, num2) {
3 return num1 + num2;
4 }
5
6
7 console.log(Add(10,20));//30
调用方式二：自调用
1 (function AddNum(num1, num2) {
2 console.log(num1 + num2);
3 })(10,20);//30
注意：自调用通常用匿名函数，由于在调用时，不须要函数名，所以，也可写成以下方式：
1 (function (num1, num2) {
2 return num1 + num2;
3 })(10, 20);//30
2.表达式调用
1 //定义两个数相加函数
2 var AddFun = function (num1, num2){
3 return num1 + num2;
4 }
5
6 console.log(AddFun(10, 20));//30
二 函数变量
在JavaScript编程语言中，变量的定义是经过var关键字来定义的(若变量不经过var定义，则为全局变量，但不推荐这么作)，与其余编程语言同样，变量也分为两大类，即局部变量和全局变量。
(1)局部变量：做用域为其所在的函数；
(2)全局变量：做用域为整个过程；
(3)变量做用域：JS中的变量做用域是经过this指针，从当前的做用域开始，从当前做用域由内向外查找，直到找到位置，这里分为几个逻辑：
a.从当前做用域由内向外查找,若找到，就中止查找，不然，继续查找，直到查到window全局做用域为止；
b.当内部做用域变量名与外部做用域变量名相同时，内部做用域的覆盖外部做用域。
咱们来看一个例子：
1 var dateTime='2018-09-16';
2 function GetUserInfo(){
3 var age=120;
4 var name="Alan_beijing";
5 function Say(){
6 var name="老王";
7 var address="shanghai";
8 console.log(address+"-"+name+"-"+age+"-"+dateTime);//shanghai-老王-2018-06-05
9 }
10 return Say();
11 }
12
13
14 GetUserInfo();//shanghai-老王-120-2018-09-16
来分析一下变量及其做用域：
如上图，有4个做用域，当函数执行以下语句时，发生以下过程：
1 console.log(address+"-"+name+"-"+age+"-"+dateTime);
a.js当前this环境做用域为4做用域；
b.this指针寻找变量：addresss,name,age,dateTime，从当前做用域向外做用域逐层寻找，直到寻找到变量为止,若寻找到最外层做用域任然没找到，则会出错，提示该变量未声明；
c.当内外层变量相同时，内层变量覆盖外层变量，如4做用域的name覆盖3做用域的name;
三 函数声明式定义存在的问题
在js中，存在声明提早问题，看看以下例子。
1 var globleName="Alan_beijing";
2 function Say(){
3 console.log(localName); // undefined,不报错，是由于变量声明提早
4 var localName="Alan";
5 console.log(localName);// Alan
6 }
看过如上代码，你可能会问，函数执行到console.log(localName); 时，应该报错，由于localName未定义。
若是在后端语言，如java,.net中，可能会报错，可是在js中，却不会，不报错的缘由是：在js中存在声明提早。
如上代码至关于以下代码：
1 var globleName="Alan_beijing";
2 function Say(){
3 var localName;
4 console.log(localName);
5 localName="Alan";
6 console.log(localName);
7 }
四 函数几大关键点
1.匿名函数
匿名函数，顾名思义，就是没名字的的函数，咱们来看看以下两个例子：
函数表达式
1 //定义两个数相加函数
2 var AddFun=function (num1, num2) {
3 return num1 + num2;
4 }
当即执行函数
(function AddNum(num1, num2) {
console.log(num1 + num2);
})(10,20);//30
从如上，不难看出，匿名函数主要用域函数表达式和当即执行函数。
2.闭包
闭包的根源在于变量的做用域问题。
咱们先来考虑这样一个问题，假设在面向对象编程语言中，某个方法的变量被定义为私有变量，其余函数要获取访问该变量，.net怎么处理？
方法一：构造函数
方法二：单例模式
一样地，在js中，一样存在外部函数调用内部函数变量问题，js运用的技术就叫作闭包。
所谓闭包,就是将不可访问的变量做为函数返回值的形式返回来，从而实现函数外部访问函数内部变量目的。
1 //闭包
2 function GetName() {
3 var name = "Alan_beijing";
4 var age = function () {
5 var age = 30;
6 return age;
7 }
8 return name + age;
9 }
3.js多态问题(重载问题)
在面向对象编程语言，如.net中，实现多态的方式大体有以下：
a.接口
b.抽象类
c.虚方法
d.方法重载
然而，在js中，没有面向对象之说(OO)，那么js是如何实现多态的呢？根据方法实际传递的参数来决定。
1 //重载
2 function SetUserInfo(userName, age, address, tel, sex) {
3 console.log(arguments.length);//4
4 }
5
6 SetUserInfo('Alan_beijing',44,'china-shanghai','xxxx');
从如上能够看出，传递多少个参数，就接收多个参数，若是在现象对象编程语言中实现该功能，至少须要写一堆代码，这也是体现js强大之一。
4.递归
来看看一个递归阶乘函数
1 //递归
2 function factorial(num) {
3 if (num < 1) {
4 return 1;
5 } else {
6 return num * arguments.callee(num-1);
7 }
8 }
若是是.net，咱们通常会这样写
1 //递归
2 function factorial(num) {
3 if (num < 1) {
4 return 1;
5 } else {
6 return num * factorial(num-1);
7 }
8 }
然而，这样写，却会存在异常状况
1 var factorial1 = factorial;
2 factorial = null;//将factorial变量设置为null
3 console.log(factorial1(4));//出错
5.原型和原型链
面向对象编程语言的显著特征之一是面向对象，然而，在js中，没有对象，那么js是如何面向对象的功能的呢（封装，继承，多态）？固然是经过原型和原型链来实现的。
这是我第一次发表博客。之前常常到博客园查找相关技术和代码，今天在写一段小程序时出现了问题，
但在网上没能找到理想的解决方法。故注册了博客园，想与新手分享（由于本人也不是什么高手）。
vb.net和C#操做Oracle数据库已经用了N多年了。因为是作工程自动化项目的，业主只对软件的功能和
界面是否友好来断定成果的好坏。因此一直都是采用直接OracleCommand.ExecuteNonQuery(sqlString,conn)
的方式很直白的Insert、update和delete数据库表的。因为工程项目并无很高的实时性，因此......
最近手头没太多事情，就在博客园逛逛。看到了ODP.NET，发现了本身有点落伍了，因而照猫画虎的练练。
在Insert时顺风顺水的，但Update时出现了“ORA-01722: 无效数字”。各类找问题，网上查资料无果。
测试表只有两个字段，varchar2和number。问题代码以下：
using Oracle.ManagedDataAccess.Client;
private void UpdateTable()
{
int valueStart = (int)NudStartValue.Value;
int valueCount = (int)NudValueCount.Value;
int returnValue = 0;
int[] columnValue = new int[valueCount];
string[] columnStr = new string[valueCount];
string sql = string.Empty;
OracleParameter[] parameters = new OracleParameter[]
{
new OracleParameter(":sname", OracleDbType.Varchar2),
new OracleParameter(":svalue",OracleDbType.Int32)
};
parameters[0].Direction = ParameterDirection.Input;
parameters[1].Direction = ParameterDirection.Input;
for ( int i = 0 ; i < valueCount ; i++ )
{
columnStr[i] = "No:" + ( i + valueStart ).ToString();
columnValue[i] = i + valueStart + 100;
}
parameters[0].Value = columnStr;
parameters[1].Value = columnValue;
sql = "update DIST_TEST set SVALUE=:svalue where SNAME=:sname";
returnValue = db.RunUpdateSQL(sql, parameters, valueCount);
MessageBox.Show(returnValue.ToString());
}
public int RunUpdateSQL(string sqlStr,OracleParameter[] parameters,int paraCount)
{
int returnValue = 0;
try
{
Open();
OracleCommand cmd = new OracleCommand()
{
Connection = Conn,
ArrayBindCount=paraCount,
CommandText=sqlStr,
CommandTimeout=240
};
cmd.Parameters.AddRange(parameters);
returnValue=cmd.ExecuteNonQuery();
cmd.Dispose();
}
catch(Exception ex)
{
Console.WriteLine(ex.ToString());
}
return returnValue;
}
解决方法：将parameters的元素按sqlStr的顺序更改一下OK了。
private void UpdateTable()
{
int valueStart = (int)NudStartValue.Value;
int valueCount = (int)NudValueCount.Value;
int returnValue = 0;
int[] columnValue = new int[valueCount];
string[] columnStr = new string[valueCount];
string sql = string.Empty;
OracleParameter[] parameters = new OracleParameter[]
{
new OracleParameter(":svalue",OracleDbType.Int32),
new OracleParameter(":sname", OracleDbType.Varchar2)
};
parameters[0].Direction = ParameterDirection.Input;
parameters[1].Direction = ParameterDirection.Input;
for ( int i = 0 ; i < valueCount ; i++ )
{
columnStr[i] = "No:" + ( i + valueStart ).ToString();
columnValue[i] = i + valueStart + 100;
}
parameters[0].Value = columnValue;
parameters[1].Value = columnStr;
sql = "update DIST_TEST set SVALUE=:svalue where SNAME=:sname";
returnValue = db.RunUpdateSQL(sql, parameters, valueCount);
MessageBox.Show(returnValue.ToString());
}
注意上面的代码，第一个出现的是:svalue，第二个出现的是:sname。OracleParameter[]按这个顺序添加就OK了。
其实如今问题是解决了，但还没能理解，:sname和:svalue是对应的parameter.value的，为什么必定要按照update语句中
变量的顺序呢。但愿高手提示一下，多谢！
但愿能帮到遇到一样问题的童鞋们。
生成解决方案 F6,生成项目Shift+F6
调试执行F5，终止调试执行Shift+F5
执行调试Ctrl+F5
查找下一个F3，查找上一个Shift+F3
附加到进程Ctrl+Alt+P，逐过程F10，逐语句执行F11
切换断点F9（添加或取消断点）
运行至光标处Ctrl+F10
跳出当前方法Shift+F11
新建解决方案：Ctrl+Shift+N
打开解决方案：Ctrl+Shift+O
保存文件Ctrl+S,保存全部文件Ctrl+Shift+S
查看解决方案窗口Ctrl+W,Ctrl+S
查看属性窗口Ctrl+W,Ctrl+P
错误列表显示Ctrl+W,Ctrl+E
输出列表显示Ctrl+W,Ctrl+O
书签窗口Ctrl+W,B
切换书签Ctrl+B,T
切换到下一个书签Ctrl+B，N
切换到上一个书签Ctrl+B，P
清除书签Ctrl+B,C
活动窗口切换Ctrl+Tab
浏览器窗口Ctrl+W,W
断点窗口Ctrl+D,B
即便窗口Ctrl+D,I
工具箱Ctrl+W，Ctrl+X
全屏切换Shift+Alt+Enter，向后导航Ctrl+-，向前导航Ctrl+Shift+-
项目中添加类Shift+Alt+C
项目中添加新项Ctrl+Shift+A
项目中添加现有项Shift+Alt+A
查找Ctrl+F，在文件中查找Ctrl+Shift+F
渐进式搜索Ctrl+I,反式渐进式搜索Ctrl+Shift+I
替换Ctrl+H，在文件中替换Ctrl+Shift+H
转到行号Ctrl+G
剪切板循环Ctrl+Shift+V 注：在剪贴板中能够循环保存20项，您能够任意的调用你剪切过的内容，只要不断的按Ctrl+Shift+V键直到找到须要的那一项
游标移动一个单词 Ctrl+左右箭头
滚动代码屏幕，但不移动光标位置Ctrl+上下箭头
删除当前行Ctrl+Shift+L
隐藏或展开当前嵌套的折叠状态 Ctrl+M，M
全部隐藏或展开嵌套Ctrl+M,L
折叠到定义Ctrl+M,O
切换显示空白Ctrl+E,S
选择矩形文本Shift+Alt+方向键
全变为大写：Ctrl+Shift+U 全变为小写Ctrl+U
强制智能感知 Ctrl+J
查看方法参数信息Ctrl+Shift+空格
查看当前代码快速信息Ctrl+K,I
注释选中行Ctrl+K,C或Ctrl+E,C
取消注释行Ctrl+K,U或者Ctrl+E,U
插入代码段Ctrl+K,X
插入外侧代码段Ctrl+K,S
转到定义F12
生成方法存根，光标定位在调用的方法上，按Shift+Alt+F10
显示查看实现接口方法，光标定位在类要实现的接口上，按Shift+Alt+F10
查看全部引用，Ctrl+K,R
查看调用层次Ctrl+K,T
除上述这些经常使用的快捷键外，若是开发人员想查看系统快捷或扩展本身的快捷键，能够打开vs-【工具】-【选项】
在窗口中选中【环境】-【键盘】
搜索想要添加的快捷键功能。
出处：http://www.cnblogs.com/xuwendong/