JavaScript中级笔记
<html>
<head>
<title>demo</title>
<meta http-equiv=”Content-Type” content=”text/html; charset=utf-8″ />
<script type=”text/javascript”>
/*
示例操作DOM元素
*/
window.onload = function(){
//给Dom元素添加颜色
var li = document.getElementsByTagName(”li”);
for(var i=0;i<li.length;i++){
li[i].style.color = “red”;
}
}
</script>
</head>
<body>
<ul>
<li>李老师-英语</li>
<li>张老师-数学</li>
<li>刘老师-物理</li>
</ul>
</body>
</html>
<html>
<head>
<title>demo</title>
<meta http-equiv=”Content-Type” content=”text/html; charset=utf-8″ />
<script type=”text/javascript”>
/*
示例操作DOM元素
*/
window.onload = function(){
//给Dom元素添加颜色
var li = document.getElementsByTagName(”li”);
for(var i=0;i<li.length;i++){
li[i].style.color = “red”;
}//删除第二个li元素
var ul = document.getElementsByTagName(”ul”)[0]; //索引从0开始
ul.removeChild( li[1] ); //索引从0开始
}
</script>
</head>
<body>
<ul>
<li>李老师-英语</li>
<li>张老师-数学</li>
<li>刘老师-物理</li>
</ul>
</body>
</html>
window.onload = function(){
//给Dom元素添加颜色
var li = document.getElementsByTagName(”li”);
for(var i=0;i<li.length;i++){
li[i].style.color = “red”;
}//删除第二个li元素
//var ul = document.getElementsByTagName(”ul”)[0]; //索引从0开始
//ul.removeChild( li[1] ); //索引从0开始
li[1].parentNode.removeChild( li[1] ); //索引从0开始,直接使用parentNode来获取li元素的父节点
}
<html>
<head>
<title>demo</title>
<meta http-equiv=”Content-Type” content=”text/html; charset=utf-8″ />
<script type=”text/javascript”>
/*
示例操作DOM元素
*/
window.onload = function(){
//给Dom元素添加颜色
var li = document.getElementsByTagName(”li”);
for(var i=0;i<li.length;i++){
li[i].style.color = “red”;
li[i].onmouseover = function(){
this.style.color = “blue”;
}
li[i].onmouseout = function(){
this.style.color = “red”;
}
}
}
</script>
</head>
<body>
<ul>
<li>李老师-英语</li>
<li>张老师-数学</li>
<li>刘老师-物理</li>
</ul>
</body>
</html>
<script type=”text/javascript”>
/*
示例用一个对象组合表示学校中的课程
‘Lecture’类
用name和teacher作为参数
*/
function Lecture(name,teacher){
this.name=name;
this.teacher=teacher;
}
//‘Lecture’类的一个方法,用于生成一条信息
Lecture.prototype.display=function(){
return this.name + ” 是教 “+this.teacher +” 的。” ;
}
//下面用new来构造一个新的函数,然后调用display方法
var L = new Lecture(”李老师”,”英语”);
var L_msg = L.display();
alert(L_msg);
</script>
<script type=”text/javascript”>
/*
示例用一个对象组合表示学校中的课程
‘Lecture’类
用name和teacher作为参数
*/
function Lecture(name,teacher){
this.name=name;
this.teacher=teacher;
}
//‘Lecture’类的一个方法,用于生成一条信息
Lecture.prototype.display=function(){
return this.name + ” 是教 “+this.teacher +” 的。” ;
}
//下面用new来构造一个新的函数,然后调用display方法
var L = new Lecture(”李老师”,”英语”);
var L_msg = L.display();
//alert(L_msg);//新定义一个’AllLecture’类
//用’lec’作为参数,lec是一个数组
function AllLecture( lec ){
this.lec = lec;
}
//‘AllLecture’类的一个方法,用于生成所有的课程信息
//需要循环输出‘lec’
AllLecture.prototype.display=function(){
var str = “”;
for(var i=0;i<this.lec.length;i++){
str += this.lec[i] + “\n”;
}
return str;
}
//下面使用new来够造一个新的函数,用于生成所有的信息
//函数的参数是数组。
//使用’Lecture’类来生成数组的值。
var B = new AllLecture( [ new Lecture("李老师","英语").display() , new Lecture("张老师","数学").display() , new Lecture("刘老师","物理").display() ] );
var B_str = B.display();
alert(B_str);
</script>
最终结果会输出:
本例中, 数组的值都调用了 display()方法。
改进如下:
在
AllLecture.prototype.display=function(){
var str = “”;
for(var i=0;i<this.lec.length;i++){
str += this.lec[i] + “\n”;
}
return str;
}
中的this.lec[i] 处,统一调用display()方法。然后去掉数组的值调用display()。修改后的代码如下:
<script type=”text/javascript”>
/*
示例用一个对象组合表示学校中的课程
‘Lecture’类
用name和teacher作为参数
*/
function Lecture(name,teacher){
this.name=name;
this.teacher=teacher;
}
//‘Lecture’类的一个方法,用于生成一条信息
Lecture.prototype.display=function(){
return this.name + ” 是教 “+this.teacher +” 的。” ;
}
//下面用new来构造一个新的函数,然后调用display方法
var L = new Lecture(”李老师”,”英语”);
var L_msg = L.display();
//alert(L_msg);//新定义一个’AllLecture’类
//用’lec’作为参数,lec是一个数组
function AllLecture( lec ){
this.lec = lec;
}
//‘AllLecture’类的一个方法,用于生成所有的课程信息
//需要循环输出‘lec’
AllLecture.prototype.display=function(){
var str = “”;
for(var i=0;i<this.lec.length;i++){
//str += this.lec[i] + “\n”;
str += this.lec[i].display() + “\n”; //把display()放到这里调用
}
return str;
}
//下面使用new来够造一个新的函数,用于生成所有的信息
//函数的参数是数组。
//使用’Lecture’类来生成数组的值。
//var B = new AllLecture( [ new Lecture("李老师","英语").display() , new Lecture("张老师","数学").display() , new Lecture("刘老师","物理").display() ] );
var B = new AllLecture( [ new Lecture("李老师","英语") , new Lecture("张老师","数学") , new Lecture("刘老师","物理") ] );
var B_str = B.display();
alert(B_str);
</script>
同样也可以输出跟上例一样的结果。
<script type=”text/javascript”>
/*示例引用*/
var obj = new Object(); //定义一个空对象
var newObj = obj; //定义一个新对象引用。
obj.name = “rain”;//修改原对象的属性
alert( newObj.name );
alert( obj.name == newObj.name );//由此可以证明它们是引用的同一个对象
</script>
本例中,两个对象都指向同一个对象,当修改某一个对象的属性内容时,则会影响另一个。
<script type=”text/javascript”>
/*示例引用*/
var arr = new Array(”a”,”b”,”c”); //定义一个数组
var newArr = arr; //定义一个新数组的引用。
arr.push(”d”);//添加一个值
alert( newArr[3] );
alert( arr.length == newArr.length );//由此可以证明它们是引用的同一个数组对象
</script>
<script type=”text/javascript”>
/*示例引用*/
var arr = new Array(”a”,”b”,”c”); //定义一个数组
var newArr = arr; //定义一个新数组的引用。
arr = new Array(”e”,”f”); //重新定义一个数组
//newArr和arr现在指向不同的对象了
//arr指向的是new Array(”e”,”f”);
//newArr指向的是 new Array(”a”,”b”,”c”);
alert(arr!=newArr);
</script>
<script type=”text/javascript”>
/*示例引用*/
var str = “a”;
var newStr = str;
str = str + “b”;//修改str的值,注意,这将会创建一个新对象,而非修改原对象
alert(str!=newStr);
</script>
<script type=”text/javascript”>
//定义一个发送信息的简单函数
//obj为发送的对象,msg为发送的信息
function sendMsg( obj , msg ){
if(arguments.length==2){
alert(obj + ” 发送:” + msg);
}else{
alert(”参数数量不对,不能发送”);
}
}//仅用一个参数时
sendMsg(”hello”);
//用2个参数时
sendMsg(”李老师”,”hello”);
</script>
arguments是一个非常有用的东西,在看下面的一个功能函数,它能将任意数量的参数转换为数组。
<script type=”text/javascript”>
function makeArr(){
var arr = [];//定义一个临时数组
for(var i=0;i<arguments.length;i++){
arr.push( arguments[i] );//添加值
}
return arr;//返回数组
}var a = makeArr(”a”,”b”,3,4);
alert(a.length);
</script>
2-2,判断传入参数的类型
第一种判断类型的方式:
判断类型需要用到JavaScript中另一个操作符――typeof。 它用来表达变量内容的类型,返回的是字符串。比如如果一个变量是字符串,那么typeof后,则返回( “string” )。
经常我们会用到如下判断:
if( typeof num == “string” ){
num = parseInt( num );//如果是一个字符串,则把字符串解析出整数
}
if( typeof arr== “string” ){
arr= arr.split(”,”);//如果是一个字符串,则根据逗号来分割成数组
}
<script type=”text/javascript”>
function makeArr(){
var arr = [];//定义一个临时数组
for(var i=0;i<arguments.length;i++){
if(typeof arguments[i] !=”string”){ continue;};
arr.push( arguments[i] );//添加值
}
return arr;//返回数组
}var a = makeArr(”a”,”b”,3,4);
alert(a.length);
</script>
最终结果 a.length 为2,因为后面2个参数是number 类型。
if( num.constructor == String ){
num = parseInt( num );//如果是一个字符串,则把字符串解析出整数
}
if( arr.constructor == String ){
arr= arr.split(”,”);//如果是一个字符串,则根据逗号来分割成数组
}
if( newArr.constructor == Array ){
newArr = newArr.join(”,”);//如果是一个数组,则根据逗号来组成字符串
}
执行constructor后的结果是一个对象,而执行typeof后的结果是一个字符串。看下表的对比:
变量 | typeof 变量 | 变量.constructor |
{a:”b”} | “object” | Object |
["a","b"] | “object” | Array |
function(){} | “function” | Function |
“a” | “string” | String |
66 | “number” | Number |
true | “boolean” | Boolean |
new User() | “object” | User |
所有的面向对象的语言都有某种形式的作用域,JavaScript也不例外。在JavaScript里,作用域是由函数划分的,而不是由块(while,if之类的)来划分的。
<script type=”text/javascript”>
var foo = “a”; //设置全局变量foo
if(true){
var foo = “b”;//在if块中,把foo的值改为b,注意:此时还在全局作用域中
}
alert(foo);
</script>
在if块中,虽然foo的值改为“b“,但还是在全局作用域中,所以输出结果是“b“。
<script type=”text/javascript”>
var foo = “a”; //设置全局变量foo
if(true){
var foo = “b”;//在if块中,把foo的值改为b,注意:此时还在全局作用域中
}
alert(foo);
alert(”window的属性:”+window.foo);
alert(window.foo == foo);//true,证明全局变量和window属性一致
</script>
我们再上例的基础上,再添加一个函数来修改foo的值,代码如下:
<script type=”text/javascript”>
var foo = “a”; //设置全局变量foo
if(true){
var foo = “b”;//在if块中,把foo的值改为b,注意:此时还在全局作用域中
}
alert(foo);//创建一个会修改foo变量的函数
function change(){
var foo = “c”;//修改foo的值
alert(”函数内部的值为:”+foo); //代码①
}
change();//然后调用时,foo只在函数作用域内起作用,所以下面输出的foo还是“b”
alert(”函数外部的值为:”+foo); //代码②
</script>
<script type=”text/javascript”>
var foo = “a”; //设置全局变量foo
if(true){
var foo = “b”;//在if块中,把foo的值改为b,注意:此时还在全局作用域中
}
alert(foo);//创建一个会修改foo变量的函数
function change(){
// var foo = “c”;
foo = “c”;//修改foo的值,去掉var声明,
alert(”函数内部的值为:”+foo);
}
change();
alert(”函数外部的值为:”+foo);
</script>
在JavaScript中,如果变量没有显式定义,它就是全局定义的。所以调用change()后,会修改全局foo的值。最终输出”c” 。
<script type=”text/javascript”>
//定义一个对象
var obj = {
show : function(){
this.display = “show”;
} ,
hide : function(){
this.display = “hide”;
}
}alert(obj.display);//此时为undefined
obj.show();//执行show函数后,将display属性跟obj对象联系起来了
alert(obj.display);//”show”
</script>
<script type=”text/javascript”>
//定义一个对象
var obj = {
show : function(){
this.display = “show”;
} ,
hide : function(){
this.display = “hide”;
}
}alert(obj.display);//此时为undefined
obj.show(); //执行show函数后,将display属性跟obj对象联系起来了
alert(obj.display);//”show”window.hide = obj.hide;//把window.hide指向obj.hide
window.hide();//执行。hide的上下文对象是window对象了,所以this将指向window对象
alert(obj.display);//”show”。obj对象的display属性值不变,因为hide的上下文已经改变为window对象了
alert(window.display);//”hide”。 window对象的display属性被更新了
</script>
本例中,我们把obj.hide变量的上下文对象变为window对象时,代码写得并不好理解。幸运的是,JavaScript提供了一套更好的方法来解决。
<script type=”text/javascript”>
//定义一个对象
var obj = {
show : function(){
this.display = “show”;
} ,
hide : function(){
this.display = “hide”;
}
}alert(obj.display);//此时为undefined
obj.show(); //执行show函数后,将display属性跟obj对象联系起来了
alert(obj.display);//”show”//window.hide = obj.hide;//把window.hide指向obj.hide
//window.hide();//执行。hide的上下文对象是window对象了,所以this将指向window对象
obj.hide.call( window );
alert(obj.display);//”show”。obj对象的display属性值不变,因为hide的上下文已经改变为window对象了
alert(window.display);//”hide”。 window对象的display属性被更新了
</script>
<script type=”text/javascript”>
//定义一个对象
var obj = {
show : function(){
this.display = “show”;
} ,
hide : function(msg1,msg2){
this.display = msg1+” , “+msg2;
}
}alert(obj.display);//此时为undefined
obj.show(); //执行show函数后,将display属性跟obj对象联系起来了
alert(obj.display);//”show”//window.hide = obj.hide;//把window.hide指向obj.hide
//window.hide();//执行。hide的上下文对象是window对象了,所以this将指向window对象
obj.hide.call( window , “a” , “b” ); //传递3个参数,第一个是上下文对象,后面的是函数的参数
alert(obj.display);//”show”。obj对象的display属性值不变,因为hide的上下文已经改变为window对象了
alert(window.display);//”hide”。 window对象的display属性被更新了
</script>
<script type=”text/javascript”>
//定义一个对象
var obj = {
show : function(){
this.display = “show”;
} ,
hide : function(msg1,msg2){
this.display = msg1+” , “+msg2;
}
}alert(obj.display);//此时为undefined
obj.show(); //执行show函数后,将display属性跟obj对象联系起来了
alert(obj.display);//”show”//window.hide = obj.hide;//把window.hide指向obj.hide
//window.hide();//执行。hide的上下文对象是window对象了,所以this将指向window对象
obj.hide.apply( window , ["a","b"] ); //后面的参数为数组
alert(obj.display);//”show”。obj对象的display属性值不变,因为hide的上下文已经改变为window对象了
alert(window.display);//”hide”。 window对象的display属性被更新了
</script>
<html>
<head>
<title>demo</title>
<meta http-equiv=”Content-Type” content=”text/html; charset=utf-8″ />
<script type=”text/javascript”>
function changeColor(color){
this.style.color = color;
}
function setBodyColor(){
changeColor.apply( document.body , ["blue"]);
}window.onload = function(){
//changeColor(”red”);//在window对象中调用此函数会失败,因为window对象没有style属性
var div = document.getElementById(”abc”);
changeColor.call(div , “red”);//把上下文改为div。从而this指向的是 id为abc的元素
//changeColor.apply(div , ["red"]);//把上下文改为div。从而this指向的是 id为abc的元素
setBodyColor();
}
</script>
</head>
<body>
<div id=”abc”>CssRain</div>
TestTest
</body>
</html>
在setBodyColor函数中,apply的第二个参数是数组,而前面我们讲过,arguments 也是一个伪数组,那么它们2个能联系起来吗?
<html><head>
<title>demo</title>
<meta http-equiv=”Content-Type” content=”text/html; charset=utf-8″ />
<script type=”text/javascript”>
function changeColor(color){
this.style.color = color;
}
function setBodyColor(){
changeColor.apply( document.body , arguments);
}window.onload = function(){
//changeColor(”red”);//在window对象中调用此函数会失败,因为window对象没有style属性
var div = document.getElementById(”abc”);
changeColor.call(div , “red”);//把上下文改为div。从而this指向的是 id为abc的元素
//changeColor.apply(div , ["red"]);//把上下文改为div。从而this指向的是 id为abc的元素
setBodyColor(”blue”);
}
</script>
</head>
<body>
<div id=”abc”>CssRain</div>
TestTest
</body>
</html>
闭包意味着内层的函数可以引用存在于包围它的函数内的变量,即使外层函数的执行已经终止。
让我们先来看一个闭包的例子。
<script type=”text/javascript”>
function add(num){
return function(toAdd){
return num+toAdd; //代码①
}
}var addFive = add(5); //此时addFive为function(toAdd){return num+toAdd;}
var count = addFive(3); //此时count为 num+toAdd
alert(count);//8
</script>
代码①是处于函数内层,不过它可以使用外层的变量num。
闭合还能解决另一个常见的Js问题,全局变量的影响。
通过自动执行匿名函数组合闭包,便可把原本属于全局的变量隐藏起来。看下面的例子:
<script type=”text/javascript”>
(function(){
var msg = “Hello”;
window.onunload = function(){
alert(msg);//输出Hello
}
})()//alert(msg);//出现未定义
</script>
在使用setTimeout时,我们经常也用上了闭包。
<html>
<head>
<title>demo</title>
<meta http-equiv=”Content-Type” content=”text/html; charset=utf-8″ />
<script type=”text/javascript”>
window.onload = function(){
var obj = document.getElementById(”abc”);
obj.style.border = “1px solid #000″;
setTimeout(function(){
obj.style.color = “red”;
},1000)function DeAlert(msg , time){
setTimeout( function(){
alert(msg);
},time)
}
DeAlert(”hello”,2000);
}
</script>
</head>
<body>
<div id=”abc”>CssRain</div>
</body>
</html>
以这种方式使用setTimeout(),可以避免一些问题。
当然使用闭包 也会带来一些问题。如下代码所示:
<html xmlns=”http://www.w3.org/1999/xhtml”>
<head>
<title>demo</title>
<meta http-equiv=”Content-Type” content=”text/html; charset=utf-8″ />
<script type=”text/javascript”>
window.onload = function(){
var ul = document.getElementById(”abc”);
var li = document.getElementsByTagName(”li”);
for(var i=0;i<li.length;i++){
li[i].onclick = function(){
alert(”你单击的是第”+i+”个li。”);
}
}
}
</script>
</head>
<body>
<ul id=”abc”>
<li>AAA</li>
<li>BBB</li>
<li>CCC</li>
</ul>
</body>
</html>
单击li弹出的序号为 3 ,并不是正确的序号,它引用的值是最后一次的赋值。
我们可以使用下面代码来解决:
<script type=”text/javascript”>
window.onload = function(){
var ul = document.getElementById(”abc”);
var li = document.getElementsByTagName(”li”);
for(var i=0;i<li.length;i++){
(function(){ //使用一个自执行的匿名函数 来激发出作用域
var b = i ; //记住在这个作用域内的值
li[b].onclick = function(){ //使用刚才记住的值,变量b
alert(”你单击的是第”+b+”个li。”);
}
})()
}
}
</script>
通过使用闭包对作用域的控制,从而符合了我们的要求。
上面的代码可以分解为:
<script type=”text/javascript”>
window.onload = function(){
var ul = document.getElementById(”abc”);
var li = document.getElementsByTagName(”li”);
function a(){
var b = 0 ;
li[b].onclick = function(){
alert(”你单击的是第”+b+”个li。”);
}
}
function b(){
var b = 1 ;
li[b].onclick = function(){
alert(”你单击的是第”+b+”个li。”);
}
}
function c(){
var b = 2 ;
li[b].onclick = function(){
alert(”你单击的是第”+b+”个li。”);
}
}
a();
b();
c();
}
</script>
6,小结
笔记(2),(3),(4)讲解了 JavaScript中的几个重要的内容,包括引用,函数重载,作用域,上下文对象和闭包。
引用的关键内容: 指针,数组引用,字符串引用,区别,传值,传址。
函数重载的关键内容: 参数的数量,参数的类型,arguments,伪数组,typeof,constructor,区别-字符串和对象。
作用域的关键内容: 函数划分,全局作用域,全局对象,window对象的属性,局部作用域,显式声明,隐式声明。
上下文对象的关键内容: this变量,call,apply,参数区别,数组。
闭包的关键内容: 内层函数,外层函数,变量,setTimeout,闭包问题,最后一次的赋值,闭包和作用域。
<script type=”text/javascript”>
//创建一个新的Object对象,存放在obj变量中
var obj1 = new Object();
//设置属性
obj1.value = 5;
obj1.click = function(){
alert(”Hello”);
}//另一种方式定义一个对象,以键值(key/value)的方式定义属性
var obj2 = {
value : 5,
click : function(){
alert(”Hello”);
}
};
</script>
<script type=”text/javascript”>
//一个简单的函数,接受名称并将其放入当前上下文中
function User(name){
this.name = name;
}var me = new User(”cssrain”);//指定名称来创建该函数的一个新对象
alert( me.name );//”cssrain”
alert( me.constructor == User );//true//如果把User当作函数
User(”peter”);
alert( window.name );//因为它的this上下文对象未设定,所以默认是全局的window对象
</script>
<script type=”text/javascript”>
//一个简单的函数,接受名称并将其放入当前上下文中
function User(name){
this.name = name;
}
//将一个新的函数添加到此对象的prototype对象中
User.prototype.getName = function(){
return this.name;
}var me = new User(”cssrain”);//指定名称来创建该函数的一个新对象
alert( me.getName() ); //”cssrain”
</script>
4,私有方法
<script type=”text/javascript”>
//一个简单的函数,接受名称并将其放入当前上下文中
function User(name){
this.name = name;
function disp(){
alert(”User()函数 私有的”);
}
//只能内部调用
disp();
}var me = new User(”cssrain”);//指定名称来创建该函数的一个新对象
//me.disp();//不能调用
//disp();//不能调用
</script>
5,特权方法
<script type=”text/javascript”>
function User(name,age){
//私有变量
var year = (new Date()).getFullYear()-age;
//创建一个特权方法,能够访问year变量,同时属于公共可访问
this.getBornYear = function(){
return year;
}
}var me = new User(”cssrain”,22);//指定参数来创建该函数的一个新对象
alert( me.getBornYear() );//”1986″
</script>
本质上,特权方式是动态生成的。因为它们是在运行时才添加到对象中的,而不是在代码第一次编译时就已经生成。
这种动态生成代码的能力不可小视,能根据与你想那个时变量来生成代码是非常有用的。看下面动态生成方法的例子:
<script type=”text/javascript”>
function User( users ){
for(var i in users){//遍历所有的属性
(function(method){
var p = i;
method["get"+p]=function(){//创建此属性的一个读取函数
return users[p];
}
method["set"+p]=function(val){//创建此属性的一个设置函数
users[p] = val;
}
})(this);
}
}var me = new User({name : “cssrain”, age : 22});//指定参数来创建该函数的一个新对象
alert( me.getname() );//”cssrain”
alert( me.getage() );//”22″me.setname(”changeCssRain”);
me.setage(23);
alert( me.getname() );//”changeCssRain”
alert( me.getage() );//”23″
</script>
6,静态方法
静态方法的实质跟一般函数没有什么不同,静态方法能保证对象的命名空间的整洁。
<script type=”text/javascript”>
function User(name,age){
this.name = name;
this.age = age;
}
//添加到一个User对象的静态方法
User.cloneUser = function(user){
//创建并返回一个新的User对象
return new User( user.name , user.age );
}var u = User.cloneUser({name:”cssrian”,age:22});
alert(u.name);//”cssrain”
alert(u.age);//22
</script>
相关文章:
相关文章:
建议继续学习:
- 高性能web服务器-读书笔记 (阅读:6843)
- Unix高级环境编程系列笔记 (阅读:4498)
- MySQL 应用小笔记 (阅读:3454)
- Unix高级环境编程系列笔记 (阅读:3417)
- 《精通CSS+DIV》学习笔记 (阅读:3097)
- 读书笔记-交互设计精髓[1] (阅读:2817)
- 《高性能网站建设指南》笔记 (阅读:2577)
- 读《Web 表单设计》 (阅读:2263)
- 《瞬间之美》读书笔记 (阅读:2056)
- 读书:《SEO实战密码》 (阅读:1867)
扫一扫订阅我的微信号:IT技术博客大学习
- 作者:nick 来源: Codyy技术团队
- 标签: 笔记
- 发布时间:2009-10-20 22:45:54
- [56] IOS安全–浅谈关于IOS加固的几种方法
- [55] 图书馆的世界纪录
- [55] 如何拿下简短的域名
- [55] android 开发入门
- [53] Oracle MTS模式下 进程地址与会话信
- [53] Go Reflect 性能
- [50] 【社会化设计】自我(self)部分――欢迎区
- [49] 读书笔记-壹百度:百度十年千倍的29条法则
- [41] 程序员技术练级攻略
- [35] 视觉调整-设计师 vs. 逻辑