魔鬼字典 JavaScript 筆記 代碼比較多亂第1/3頁
//2005中ctrl+J 有可能出提示
//文本編輯出注釋的快捷鍵
名詞解釋：
{
//Java: 爪哇語言, 在因特網(wǎng)世界范圍的 web 網(wǎng)頁運(yùn)轉(zhuǎn)的以網(wǎng)絡(luò)為基礎(chǔ)的編程語言 (計算機(jī)用語)
//Script : 手稿, 劇本, 手跡
//cs結(jié)構(gòu)： 客戶端應(yīng)用程序，用戶需要下載客戶端，例如QQ
//BS結(jié)構(gòu)： 瀏覽器應(yīng)用程序，具有遠(yuǎn)程服務(wù)器，例如網(wǎng)頁
腳本語言：解釋性語言，不進(jìn)行編譯，只在運(yùn)行至相應(yīng)代碼時進(jìn)行解釋
}
完整的JavaScript組成
{
核心：ECMAScript
文檔對象模型：DOM /*Document/*文件*/ Object Model*/
瀏覽器對象模型：BOM /*Browser /*瀏覽器*/ Object Model*/
}
JavaScript作用
{
提供用戶交互
動態(tài)更改內(nèi)容
數(shù)據(jù)驗(yàn)證
}
//建站：文件→新建→網(wǎng)站→ASP.NET 網(wǎng)站→位置（文件系統(tǒng)）→語言（Visual C#）→路徑（添加合適路徑儲存網(wǎng)頁）
//添加HTML網(wǎng)頁：（在資源管理器）添加新項(xiàng)→HTML頁→起名→確定
//自動生成的HTML中第一行（<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">）表示生成文檔類型
//添加script標(biāo)簽：
{
位置：可以添加在任何位置，但是一般添加在<head></head>標(biāo)簽中
格式：
類型：
{
內(nèi)嵌腳本： 放在<head></head>標(biāo)簽中并且有JavaScript文本
例子：<script type="text/javascript" language="javascript">此處添加JavaScript文本</script>
↑
文本類型
外掛腳本（建議使用）： 放在<head></head>標(biāo)簽中，沒有方法體，只有地址
例子：<head>
<title>無標(biāo)題頁</title>
<script type="text/javascript" language="javascript" src="waigua.js">
</script> ↑
</head> 地址 擴(kuò)展名：.js
添加→添加新項(xiàng)→JScript文件→起名→添加
JScript文件中的內(nèi)容：document.write("能看見呢？");
}
}
//方法
{
document: document.write("這是我的第一個Js文本") /*相當(dāng)于Console.WriteLine*/
聲明變量： var
例子：var number=55;
強(qiáng)制轉(zhuǎn)換類型：
{
parseFloat(ppp)/*強(qiáng)制轉(zhuǎn)換為float類型，ppp為變量名*/ !注意：parseFloat的拼寫和大小寫，如果在頁面加載時出現(xiàn)錯誤則程序不向下運(yùn)行!
Boolean()強(qiáng)制轉(zhuǎn)換,當(dāng)參數(shù)為空字符串和null時，得到false ：例子: document.write(Boolean(100)+"<br/>"); /*強(qiáng)烈注意Boolean的大小寫!!!*/
var color="violet";
document.write(color.length,"<br/>"); /*強(qiáng)烈注意length的大小寫!!!*/
var num=10;
document.write("10的二進(jìn)制數(shù)為",num.toString(2),"<br/>"); 10的二進(jìn)制數(shù)為1010 /*強(qiáng)烈注意toString的大小寫!!!*/
document.write("10的八進(jìn)制數(shù)為",num.toString(8),"<br/>"); 10的八進(jìn)制數(shù)為12
document.write("10的十進(jìn)制數(shù)為",num.toString(10),"<br/>"); 10的十進(jìn)制數(shù)為10
document.write(Number(testFunction())+"<br/>"); NaN /*NaN:非數(shù)字*/
document.write(Number("123.12")+"<br/>"); 123.12
document.write(Number(false)+"<br/>"); 0
document.write(Number(true)+"<br/>"); 1
document.write(parseInt("10")+"<br/>"); 10 /*parse：解析; 符合語法*/
document.write(parseInt("56.6")+"<br/>"); 56
var str="marssion"; /*typeof運(yùn)算符，返回變量的類型*/
document.write(typeof(str)+"<br/>"); 顯示：string
var temp;
document.write(typeof(temp)+"<br/>"); 顯示：undefined /*undefined : 未定義的*/
var myObject={x:0,y:0};
document.write(typeof(myObject)+"<br/>"); 顯示： object
document.write(typeof(null)+"<br/>"); 顯示： object /*ECMAScript沿用了javascript中最初的一個錯誤，現(xiàn)在null被認(rèn)為是對象的占位符,所以返回object，從技術(shù)上來講仍是原始值。*/
var oTemp;
document.write((oTemp==undefined)+"<br/>"); 顯示： true /*注意在比較時要加（）否則比較時會把"<br/>"也加進(jìn)去*/
function testFunction(){} //如果函數(shù)沒有實(shí)現(xiàn)則返回undefined值
document.write((testFunction()==undefined)+"<br/>"); 顯示：true /*函數(shù)給調(diào)用所以給加（）*/
document.write((null==undefined)+"<br/>"); 顯示： true
}
}
//調(diào)用函數(shù)
{
function a(Sname,Smessage) /*格式： function 函數(shù)名（參數(shù)1，參數(shù)2）{函數(shù)體} 參數(shù)在定義時直接給名字就行了不需要指定類型*/
{
return Sname+Smessage;
}
var b=a("William","Welcome");
document.write(b);
}
//if語句
{
var num=10;
var num1="10";
if(num==num1)
{
document.write("相等"); /*在比較不同類型的數(shù)據(jù)時，系統(tǒng)會自動的把兩者的類型統(tǒng)一，或者把string類型轉(zhuǎn)換成int或者把int轉(zhuǎn)換成string再判斷兩者的關(guān)系*/
}
if(num!=num1)
{
document.write("不相等");
}
}
//for語句
{
for(var a=1,b=0;a<101;a++) /*輸出的是：5050*/
{
b+=a;
}
document.write(b);
}
//while語句
{
var a=1;var b=0; /*輸出的是：5050*/
while(a<101)
{
b+=a;
a++;
}
document.write(b);
}
//do while 語句
{
var a=1; /*輸出的是：5050*/
var b=0;
do
{
b+=a;
a++;
}while(a<101);
document.write(b);
}
//alert 方法 和自定義屬性 自定義object類型的變量 delete方法
{
var o=new Object(); /*定義一個oject類型的變量*/
o.name="hellow word"; /*定義屬性*/
alert(o.name); /*alert ：提防的，警惕的/*調(diào)用此方法彈出一個警告messagebox，（）中寫的是要顯示的信息*/*/
delete(o.name); /*delete 方法將引用變量的指針打斷*/
alert(o.name); /*o.name又變回undefined類型*/
}
//全等運(yùn)算符（===）
{
var sNum="55";
var tNum=55;
document.write(sNum==tNum,"<br />"); 顯示： true
document.write(sNum===tNum,"<br />"); 顯示： false /*“==”會將比較的雙方自動類型轉(zhuǎn)換成一樣的類型再進(jìn)行比較，“===”不會類型轉(zhuǎn)換直接比較，int類型自然不等于string類型所以不相等*/
document.write(sNum!=tNum,"<br />"); 顯示： false
document.write(sNum!==tNum,"<br />"); 顯示： true
}
//switch
{
var date=new Date(); /*聲明一個data類型的變量*/
var time=date.getDay(); /*獲得系統(tǒng)的當(dāng)前日期*/
switch(time)
{
case 0:
document.write("星期日");
break;
case 1:
document.write("星期一");
break;
case 2:
document.write("星期二");
break;
case 3:
document.write("星期三");
break;
case 4:
document.write("星期四");
break;
case 5:
document.write("星期五");
break;
case 6:
document.write("星期六");
break;
}
}
/**/↑↓←→
//arguments
{
function a(aa,bb,cc)
{
if(arguments.length==1) /*arguments.length屬性： 計算調(diào)用函數(shù)時傳過來的參數(shù)個數(shù)，可以模擬參數(shù)重載*/
{
document.write(aa+"<br/>"); /*argument[0] argument[1] argument[3] 能夠代表（）中的參數(shù)*/
}
else if(arguments.length==2)
{
document.write(aa+"~~~~~"+bb+"<br/>");
}
else if(arguments.length==3)
{
document.write(aa+" "+bb+" "+cc+"<br/>");
}
}
a("william"); 顯示：william
a("william","welcome"); 顯示：william~~~~~welcome
a("william","welcome","myhouse"); 顯示：william welcome myhouse
}
//with
{
var sMessage="hello world"; /*用了with后{}中不用再打相應(yīng)的變量名了*/
with(sMessage)
{
document.write(toUpperCase(),"<br />"); 顯示：HELLO WORLD /*toUpperCase()方法是強(qiáng)打上去的，沒有顯示，所以要特別注意大小寫*/
document.write(length,"<br />"); 顯示：11 /*length屬性是強(qiáng)打上去的，沒有顯示，所以要特別注意大小寫*/
}
}
//void用法 /*沒有返回值的*/
{
<body>
<a href="javascript:void(window.open('about:blank'))">單擊一下下</a> /*這是一個超級連接，打開一個新的窗體，不覆蓋老窗體，如果沒有void超級連接被點(diǎn)后“單擊一下下”就會變成“[object]”有了void就不會變了*/
</body>
}
//for in 用法 /*用于枚舉對象的屬性*/
{
var o=new Object();
o.name="nameshuxing";
o.age=21;
o.gender="nan";
隨便起的變量
↓
for(sss in o)
{
document.write(o[sss],"<br/>"); /*顯示的是：nameshuxing 21 nan ，“document.write(sss)”輸出的是屬性的名字/*name age gender*/ “對象[屬性名字]”顯示的是相應(yīng)屬性的內(nèi)容，就像hashtable中的查詢一樣*/
}
document.write("<b>window對象屬性</b><br/>");
for(aaa in document)
{
document.write(aaa,",<br/>");
}
}
//閉包 /*函數(shù)嵌套*/
{
function test(num1,num2)
{
var num3=10;
function inter(num4)
{
return num1+num2+num3+num4
}
return inter; /*這個return不能少，否則不能顯示*/
}
var zhi=test(10,20);
document.write(zhi(20)); /*顯示：60*/ /*zhi(20)沒有提示*/
var aa="hello world";
function a()
{
document.write(aa,"<br/>");
}
a(); /*顯示：hello world* 必須調(diào)用/
var num3=10;
function b(num1,num2)
{
function bb()
{
return num1+num2+num3;
}
return bb;
}
var bbb=b(10,20);
document.write(bbb()); /*顯示：40*/
}
JS高級編程 第二章 對象 /**/↑↓←→
//火狐瀏覽器能當(dāng)計算器，輸入“javascript:3-2”顯示1，也可以寫一些簡單的Js語句，函數(shù)什么的
//JavaScript在什么時間被執(zhí)行
{
1、在文檔被裝載的時候
2、文檔加載后 /*在文檔被加載后，<body>標(biāo)記onload()時間發(fā)生，此時文檔已經(jīng)加載完畢*/
3、被其他的JavaScript語句調(diào)用
以下取自ajax and dot。Net2.0
腳本裝載周期：
當(dāng)網(wǎng)頁被瀏覽器加載時，javascript在以下3個時間點(diǎn)被執(zhí)行
一：在文檔被裝載期間
注意：此時文檔還沒有被加載，文檔中的元素不能被使用。
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>My HTML Page</title>
</head>
<body>
<h1>During load script execution</h1>
<script type="text/javascript" language="javascript">
alert("executing during page load.");
</script>
<h1>alert has executed!</h1>
<form id="frmDefault" runat="server">
<div>
</div>
</form>
</body>
</html>
二：文檔加載后
在文檔被加載后，<body> 標(biāo)記 onload() 事件發(fā)生，此時文檔已經(jīng)加載完畢。
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>My HTML Page</title>
</head>
<script type="text/javascript" language="javascript">
function alldone()
{
alert("all done!");
}
</script>
<body onload="alldone();">
<h1>After load script execution</h1>
<h1>Final line...almost done!</h1>
<form id="frmDefault" runat="server">
<div>
</div>
</form>
</body>
</html>
三：被其他的javascript語句調(diào)用
}
//對象的官方概念 :ECMA-262把對象定義為“屬性的無序集合，每個屬性存放一個原始值、對象或函數(shù)?！边@意味著對象是無特定順序的值的數(shù)組。
//JavaScript對象分類
{
1、本地對象 例如：ECAM-262定義的對象：Object Functioin、Boolean、 Number 等
2、內(nèi)置對象 例如：Global對象、Math對象
3、宿主對象 例如：所有DOM、BOM對象
}
//對象的創(chuàng)建
{
使用new關(guān)鍵字創(chuàng)建本地對象
例如：var o=new Object();
/*應(yīng)用*/
var car = new Object();
car.name = "凱迪拉克";
car.money = 1111111;
document.write("我新買的" + car.name + "<br/>"); 顯示： 我新買的凱迪拉克
document.write("這破車花了我" + car.money + "<br/>"); 顯示：這破車花了我1111111
使用對象直接量創(chuàng)建
例如：var oo={};
var ooo={x:1,y:2};
/*應(yīng)用*/
var obj = { x: 1, y: 2 } /*格式： var 對象名={ 屬性名：值，屬性名: 值......}*/
for (mycar in obj) { /用對象直接量創(chuàng)建相當(dāng)于創(chuàng)建一個函數(shù)（函數(shù)體內(nèi)包含X Y（做成未賦值的屬性））并用一個值初始化它并把屬性賦值/
document.write(mycar + "<br/>");
}
for (aaa in obj) {
document.write(obj[aaa]+"<br/>");
}
/*顯示*/
x
y
1
2
}
//對象的屬性的表示方法
{
1、object.property
2、object["property"]
/*例子*/
var car={x:1};
car["color"]="黑色";
car["name"]="寶馬";
car["price"] = 150000;
var msg;
for(msg in car) //調(diào)用方法顯示出car中的所有屬性的名稱
{
msg+=" ";
document.write(msg);
}
/*顯示*/
x color name price
}
//JavaScript本地對象
{
Object 類 /*ECMAScript中的所有類都由這個類繼承而來 */
{
屬性
Constructor——對創(chuàng)建對象的函數(shù)的引用（指針）。對于Object類，該指針指向原始的object()函數(shù)(每個對象都有這個屬性，它指向用來初始化該對象的構(gòu)造函數(shù))
Prototype——對該對象的對象原型的引用。對于所有的類，它默認(rèn)返回Object對象的一個實(shí)例。
}
Number 類 /*代表數(shù)值數(shù)據(jù)類型和提供數(shù)值常數(shù)的對象*/
{
創(chuàng)建：numObj=new Number(value) /*一般很少這樣用，這么創(chuàng)建是引用類型的*/
屬性
MAX_VALUE 屬性|MIN_VALUE 屬性|NaN 屬性|NEGATIVE_INFINITY 屬性|POSITIVE_INFINITY 屬性|constructor 屬性|prototype 屬性
方法
toString 方法|valueOf 方法
{
/*例子*/
var num1 = mynumber.valueOf();
var num2 = mynumber.toString();
document.write(num1, "<br/>"); /*顯示：100*/ valueOf()和toString()在用法和結(jié)果上沒什么區(qū)別
document.write(num2,"<br/>"); /*顯示：100*/
}
toFixed(int值)方法 /*保留幾位小數(shù)，在銀行中有用*/
{
/*例子*/
var mynumber = new Number(100); /*顯示：100.0000*/
var num2 = mynumber.toFixed(4); /*保留四位小數(shù)*/
document.write(num2, "<br/>");
}
Number.MAX_VALUE方法和Number.MIN_VALUE方法
{
/*例子*/
var max = Number.MAX_VALUE;
var min = Number.MIN_VALUE;
document.write(max+"<br/>");
document.write(min);
/*顯示*/
1.7976931348623157e+308
5e-324
}
}
String類
{
語法：
indexOf(“查找的子字符串”，查找的起始位置)
返回子字符串所在的位置，如果沒找到，返回 －1
例如：
var x
var y=“abcdefg”;
x=y.indexOf(“c” , 0 );
//返回結(jié)果為2，起始位置是0
/*例子及其他方法*/
var str = new String("hello world 字符串示例");
//Lenght屬性
document.write(str.length, "③<br />");//獲取字符串的長度 /*顯示：17③*/
//charAt charCodeAt()
document.write(str.charAt(0), "④<br />");//獲取指定位上的字符 /*顯示：h④*/
document.write(str.charCodeAt(0), "<br />"); //獲取指定位上的字符的ascii碼 /*顯示：104*/
//concat() 與“+”號相同
var oStringObject = new String("hello ");
var sResult = oStringObject.concat("world");
document.write(sResult, "⑤<br />"); /*顯示：hello world⑤*/
document.write(oStringObject, "⑥<br />"); /*顯示：hello ⑥*/ //沒有改變本身的值
//indexOf() lastIndexOf()
var myStr = new String("hello world");
document.write(myStr.indexOf("o"), "⑦<br />"); /*顯示：4⑦*/ //下標(biāo)從0開始第一個“o”在下標(biāo)4的位置上
document.write(myStr.lastIndexOf("o"), "⑧<br />");//獲取最后一個指定字符的位置 /*顯示：7⑧*/ //下標(biāo)從0開始從后數(shù)第一個“o”在下標(biāo)7的位置上
//slice() substring() //字符串的截取，兩者不同的是“slice()”的（）中可以放負(fù)數(shù)，“substing()”的（）中如果放入負(fù)數(shù)則被系統(tǒng)看成0
document.write(myStr.slice(3), "⑨<br />"); /*顯示：lo world⑨*/ //第一個參數(shù)表示的從3開始截（包括3）沒有第二個參數(shù)就有多長截多長
document.write(myStr.substring(3), "⑩<br />"); /*顯示：lo world⑩*/ //第一個參數(shù)表示的從3開始截（包括3）沒有第二個參數(shù)就有多長截多長
document.write(myStr.slice(3, 7), " 11<br />"); /*顯示：lo w 11*/ //第一個參數(shù)表示的從3開始截（包括3）第二個參數(shù)表示截到下標(biāo)7為止（不包括7）
document.write(myStr.substring(3, 7), " 12<br />"); /*顯示：lo w 12*/ //同上
document.write(myStr.slice(-3), " 13<br />");//相當(dāng)于slice（8） 字符串長度+參數(shù) /*顯示：rld 13*/ //可以接受負(fù)數(shù)，-3表示截取字符串中的最后3個
document.write(myStr.substring(-3), " 14<br />");//負(fù)數(shù)相當(dāng)于0 /*顯示：hello world 14*/ //不能接受負(fù)數(shù)，系統(tǒng)自動轉(zhuǎn)換成0，表示從0開始截，有多長截多長
document.write(myStr.slice(3, -4), " 15<br />");//相當(dāng)于slice（3，7） /*顯示：lo w 15*/
document.write(myStr.substring(3, -4), " 16<br />");//相當(dāng)于substring（0，3）較小的數(shù)字放在第一個參數(shù)，位置自動轉(zhuǎn)化 /*顯示：hel 16*/
//toLowerCase() toUpperCase() toLocaleLowerCase() toLocaleUpperCase() //轉(zhuǎn)換大小寫，toLocaleLowerCase() toLocaleUpperCase()是基于特定的區(qū)域?qū)崿F(xiàn)的（一般用不上）
document.write(myStr.toLowerCase(), " 17<br />"); /*顯示：hello world 17*/
document.write(myStr.toLocaleLowerCase(), " 18<br />"); /*顯示：hello world 18*/
document.write(myStr.toUpperCase(), " 19<br />"); /*顯示：HELLO WORLD 19*/
document.write(myStr.toLocaleUpperCase(), " 20<br />"); /*顯示：HELLO WORLD 20*/
//big() small()
document.write(str.small()," 21<br />");//縮小字體
document.write(str.big()," 22<br />");//放大字體
//斜體字和刪除線
var ss=str.italics()+str.strike(); //italics()方法是將字體顯示為斜體， strike()方法是在顯示的字體上加上刪除線
document.write(ss);
fontcolor();設(shè)定字體顏色
/*例子*/
var a = "換個字體顏色";
a = a.fontcolor("red");
document.write(a);
sub();把字變成下標(biāo)
document.write("H"+"2".sub()+"O"); //這是字符串的方法，如果用var b = 2; b = b.sub();則行不通。
}
Math類
{
<meta http-equiv="refresh" content="2" /> //2秒自動刷新
var test=Math.E;//表示自然對數(shù)的底
document.write(test,"<br />"); /*顯示：2.718281828459045*/
test=Math.PI;
document.write(test,"<br />"); /*顯示：3.141592653589793*/
document.write("2秒自動刷新，隨機(jī)顯示圖片");
var i = 0; //Math.random( ) ：產(chǎn)生0－1的隨機(jī)小數(shù),Math.random()*10產(chǎn)生一個0-10的隨機(jī)小數(shù)
i=Math.round(Math.random()*10); //Math.round( )：四舍五入取整，如9.34 取整為9
document.write("<img width=400 height=260 src=img/"+i+".jpg>");
}
Date類
{
var 日期對象 = new Date (年、月、日等參數(shù))
例：
var mydate=new Date( “July 29, 1998,10:30:00 ”)
如果沒有參數(shù)，表示當(dāng)前日期和時間
例：
var today = new Date( )
方法
{
getYear(): 返回年數(shù) getMonth():返回當(dāng)月號數(shù) getDate(): 返回當(dāng)日號數(shù) getDay():返回星期幾 getHours():返回小時數(shù) getMintes():返回分鐘數(shù) getSeconds():返回秒數(shù) getTime() : 返回毫秒數(shù)
setYear():設(shè)置年 setDate():設(shè)置當(dāng)月號數(shù) setMonth():設(shè)置當(dāng)月份數(shù) setHours():設(shè)置小時數(shù) setMintes():設(shè)置分鐘數(shù) setSeconds():設(shè)置秒數(shù) setTime ():設(shè)置毫秒數(shù)
}
/*例子*/
//第一種參數(shù)
var someDate=new Date(2008,05,20,12,00,00);
document.write(someDate,"<br />");
//第二種參數(shù)
someDate=new Date("july 20 2008 12:30:30");
document.write(someDate,"<br />");
//獲取系統(tǒng)當(dāng)前日期
var today=new Date();
document.write(today,"<br />");
document.write("某特定時間的星期為"+today.getDay()+"<br />");//0代表星期日
document.write("某特定時間的日子為"+today.getDate()+"<br />");
document.write("某特定時間的月份為"+(today.getMonth()+1)+"<br />");//月從0月開始 0代表十二月，0~11
document.write("某特定時間的年份為"+today.getFullYear()+"<br />");
document.write("某特定時間的小時為"+today.getHours()+"<br />");
document.write("某特定時間的分鐘為"+today.getMinutes()+"<br />");
document.write("某特定時間的秒為"+today.getSeconds()+"<br />");
//通過setDate方法修改日期，其他類似
today.setDate(25);
document.write("修改后的日期為"+today.getDate()+"<br />");
/*顯示*/
Fri Jun 20 12:00:00 UTC+0800 2008
Sun Jul 20 12:30:30 UTC+0800 2008
Wed Aug 30 17:43:14 UTC+0800 2006
某特定時間的星期為3
某特定時間的日子為30
某特定時間的月份為8
某特定時間的年份為2006
某特定時間的小時為17
某特定時間的分鐘為43
某特定時間的秒為14
修改后的日期為25
/*實(shí)際用法*/
var now = new Date();
var hour = now.getHours();
if (hour >= 0 && hour <= 12)
document.write("上午好!")
if (hour > 12 && hour <= 18)
document.write("下午好!");
if (hour > 18 && hour < 24)
document.write("晚上好!");
document.write("<P>今天日期:" + now.getYear() + "年"
+ (now.getMonth() + 1) + "月" + now.getDate() + "日"); //月份數(shù)字0－11，注意＋1
document.write("<P>現(xiàn)在時間:" + now.getHours() + "點(diǎn)" + now.getMinutes() + "分" + now.getSeconds() + "秒");
/*顯示*/
下午好!
今天日期:2006年8月30日
現(xiàn)在時間:17點(diǎn)58分22秒
//setTimeout() /*一次性定時器*/ 的用法
{
setTimeout（“調(diào)用的函數(shù)”,”定時的時間”）
例：
var myTime＝setTimeout（”disptime( )”,1000）; /*定時的時間是以毫秒為單位*/ //設(shè)定定時器
clearTimeout（myTime）; //解除定時器
}
setInterval() /*循環(huán)性計時器*/ 用法同上
}
}
/**/↑↓←→
//數(shù)組
{
聲明數(shù)組三種方式
第一種 var 數(shù)組名 = new Array(); /*賦值時用：數(shù)組名[數(shù)字]=值*/ /*數(shù)組的下標(biāo)必須是大于0的數(shù)字否則就會被當(dāng)成數(shù)組的一個屬性對待*/
例： var emp = new Array()
第二種 var 數(shù)組名=new Array(5,4,3,2,1,”test”); /*數(shù)組中能放任何類型的元素*/
第三種 var misc = [ 1.1, true, "a", ];
var b = [[1,{x:1, y:2}], [2, {x:3, y:4}]];
/*理解*/
function Circle(x,y,z)
{
this.x=x;
this.y=y;
this.z=z;
}
var c=new Circle(1,2,3);
c[0]="this is an element";
c[1]="this is an element";
c[2]="this is an element";
for(var temp in c)
{
document.write(c[temp],"<br />"); /*如果（c,"<br/>"） 顯示的是 x,y,z,0,1,2*/ //顯示：1,2,3,this is an element,this is an element,this is an element
} /*c[0]說是數(shù)組實(shí)際上也可以理解成屬性，在Js中這兩者的分界線并不是十分明顯*/
var test=new Array(1,2,3,4,5);
for(var i=0;i<test.length;i++)
{
document.write(test[i],"<br />");
}
document.write("改變length的值前數(shù)組的長度：" + test.length, "<br />");
test.length=3; /*數(shù)組的長度可以自己指定，指定的長度要是比原來的?。壕妥詣影验L出的部分自動砍掉，要是指定的長度比原來的長度長，多出的部分就是undefined(未定義)*/
document.write(test, "<br />"); /*自動將元素用“，”連接*/
document.write("改變length的值后數(shù)組的長度：" + test.length, "<br />");
delete test[0]; /*用delete將數(shù)組的元素值刪除，刪除后的元素位置還在，只是沒有值*/
document.write(test, "<br />");
document.write("使用delete后數(shù)組的長度：" + test.length);
/*顯示*/
1
2
3
4
5
改變length的值前數(shù)組的長度：5
1,2,3
改變length的值后數(shù)組的長度：3
,2,3
使用delete后數(shù)組的長度：3
JavaScript并不支持真正的多維數(shù)組，但是它允許使用元素為數(shù)組
/*例子*/
var table=new Array(3);//3行
for(var i=0;i<table.length;i++)
{
table[i]=new Array(3);//每行3列
}
for(var row=0;row<table.length;row++)
{
for(var col=0;col<table[row].length;col++) /*數(shù)組之間的嵌套，賦值時：數(shù)組名[int][int]*/
{
table[row][col]=row*col;
}
}
for(var r=0;r<table.length;r++)
{
for(var c=0;c<table[r].length;c++)
{
document.write(table[r][c]+" ");
}
document.write("<br />");
}
/*顯示*/
0 0 0
0 1 2
0 2 4
//數(shù)組的方法
{
join()方法 ： 該方法可以把一個數(shù)組的所有元素有轉(zhuǎn)換成字符串，然后再把他們連接起來
/*例子*/
var test=[1,2,3];
var s = test.join("-");
document.write(test, "<br />");
document.write(s, "<br />");
/*顯示*/
1,2,3
1-2-3
reverse()方法 : 該方法將顛倒數(shù)組元素的順序并返回顛倒后的數(shù)組
/*例子*/
var test=[1,2,3,4,5,6];
test.reverse();
for (var i = 0; i < test.length; i++) /*顛倒數(shù)組對原數(shù)組也進(jìn)行了變動*/
{
document.write(test[i], "<br />");
}
/*顯示*/
6
5
4
3
2
1
sort()方法 ： 該方法在原數(shù)組上對數(shù)組元素進(jìn)行排序
/*例子*/
var fruits=["manago","orange","apple","strawberry"];//在元數(shù)組上進(jìn)行排序
var myFruits=fruits.sort();
for(var i=0;i<myFruits.length;i++)
{
document.write(myFruits[i],"<br />"); /*排序?qū)υ瓟?shù)組也進(jìn)行了改動，在對英文進(jìn)行排序時，會比對第一個英文字母按照二十六個英文字母進(jìn)行排序*/
}
for (var i = 0; i < fruits.length; i++) {
document.write(fruits[i], "<br />");
}
var test=[33,4,611,222];
test.sort(); /*直接用 數(shù)組名.sort()對數(shù)字?jǐn)?shù)組進(jìn)行排序時，并不是按照數(shù)字的大小進(jìn)行排序，而是和英文排序一樣，將數(shù)字的第一位拿出，按照大小進(jìn)行排序*/
for(var i=0;i<test.length;i++)
{
ocument.write(test[i],"<br />");
}
test.sort(function(a,b){return a-b;}); /*想對數(shù)字?jǐn)?shù)組按照數(shù)字的大小進(jìn)行排序時 test.sort(function(a,b){return a-b;}); 記住就這么用，方法中如果第一個參數(shù)應(yīng)該出現(xiàn)在第二個參數(shù)之前那么比較函數(shù)就會返回一個小于0的數(shù)，如果第一個參數(shù)應(yīng)該出現(xiàn)在第二個參數(shù)之后，那么比較函數(shù)就會返回一個大于0的數(shù)*/
for(var i=0;i<test.length;i++) /*如果對一組字符串?dāng)?shù)組進(jìn)行不分大小寫的字母排序操作使用tolowerCase()*/
{
document.write(test[i],"<br />");
}
/*顯示*/
apple
manago
orange
strawberry
apple
manago
orange
strawberry
222
33
4
611
4
33
222
611
concat()方法 ： 該方法能創(chuàng)建并返回一個數(shù)組
/*例子*/
var test=[1,2,3];
document.write(test,"<br />");
result = test.concat([8, 9]); /*添加時自動將[]去掉,只能去掉一層[],[5,[6,7]]添加后為5，[6,7]*/
for(var i=0;i<result.length;i++)
{
document.write(result[i],"<br />"); /*使用此方法只是能在原有的數(shù)組基礎(chǔ)上在創(chuàng)建一個數(shù)組，所以必須用一個變量接受，此方法對原數(shù)組沒有影響*/
}
/*顯示*/
1,2,3
1
2
3
8
9
slice()方法 ： 返回的是指定數(shù)組的子數(shù)組
/*例子*/
var test=[1,2,3,4,5,6];
var result=test.slice(0,3); /*slice(0,3) ： 0 ：從索引0開始截， 3 ：截到索引3為止（包括0不包括3），如果沒有第二個參數(shù)就將剩下的全部刪除*/
for(var i=0;i<result.length;i++)
{
document.write(result[i],"<br />");
}
/*顯示*/
1
2
3
splice()方法 ： 該方法可以把元素從數(shù)組中刪除，也可以將新元素插入到數(shù)組中，它在原數(shù)組上修改數(shù)組，并不創(chuàng)建新數(shù)組
!只在firefox中能正確瀏覽! 注意：和concat()不同，splice()并不將它插入的數(shù)組參數(shù)展開，也就是說，如果傳入的是一個數(shù)組插入的就是一個數(shù)組而不是這個數(shù)組的元素
/*例子*/
//IE瀏覽器無效，使用FireFox
var test=[1,2,3,4,5,6,7,8];
//刪除元素
var result = test.splice(4); //沒有指定第二個參數(shù)表示從起始位置刪至結(jié)尾，刪除了5，6，7，8，將刪除的數(shù)組返回
for(var i=0;i<result.length;i++)
{
document.write(result[i],"<br />");
}
document.write("---------------------------<br />");
for(var i=0;i<test.length;i++)
{
document.write(test[i],"<br />");
}
//添加元素
document.write("---------------------------<br />");
var test1=[1,2,3,4,5,6,7,8];
//第二個參數(shù)表示要刪除的元素數(shù)，0表示不刪除，直接插入，非0表示刪掉之后再插入
var addResult=test1.splice(2,4,"liwei","marssion");
for(var i=0;i<addResult.length;i++)
{
document.write(addResult[i],"<br />");
}
document.write("---------------------------<br />");
for(var i=0;i<test1.length;i++)
{
document.write(test1[i],"<br />");
}
/*顯示*/
5
6
7
8
---------------------------
1
2
3
4
---------------------------
3
4
5
6
---------------------------
1
2
liwei
marssion
7
8
push()方法和pop()方法 //方法可以將一個或多個新元素附加到數(shù)組的尾部，然后返回數(shù)組的新長度，方法pop()將刪除數(shù)組的最后的一個元素，減少數(shù)組的長度，返回它刪除的值。
//注意：這兩個方法都是在原數(shù)組上修改數(shù)組，而非生成一個修改過的數(shù)組副本，聯(lián)合使用push()和pop()，就可以用javascript實(shí)現(xiàn)一個先進(jìn)后出的棧；
/*例子*/
var temp=[];
document.write("Push<br />");
temp.push(1, 2, 3, 4);
document.write("數(shù)組元素有："+temp+"<br />數(shù)組長度是："+temp.length);
document.write("<br />");
document.write("Pop<br />");
temp.pop();
document.write("數(shù)組元素有："+temp+"<br />數(shù)組長度是："+temp.length);
/*顯示*/
Push
數(shù)組元素有：1,2,3,4
數(shù)組長度是：4
Pop
數(shù)組元素有：1,2,3
數(shù)組長度是：3
unshift()方法和shift()方法 //方法unshift()會將一個或多個元素添加到數(shù)組的頭部，然后把已有的元素移動到下標(biāo)較大的位置以騰出空間，它返回的是數(shù)組的新長度；
//方法shift()會刪除并返回數(shù)組的第一個元素，然后將后面的所有元素都向前移動以填補(bǔ)第一個元素留下的空白
/*例子*/
//先進(jìn)先出（FIFO）
var test=[];
document.write("Unshift<br />");
test.unshift(1, 2, 3, 4);
document.write(test,"<br />");
document.write("Shift<br />");
test.shift();
document.write(test,"<br />");
/*顯示*/
Unshift
1,2,3,4
Shift
2,3,4
instanceof運(yùn)算符與typeof運(yùn)算符相似，用于識別正在處理的對象的類型，不同的是，instanceof方法要求開發(fā)者明確地確定對象為某特定類型
例：var ostring=new String(“hello”)
document.write(ostring instanceof String); //返回一個boolean值，類型正確返回true否則返回false
}
}
//對象的共同屬性和方法
{
toString() //object類的方法，將非字符串轉(zhuǎn)換成字符串
toLocaleString() //object類的方法，返回對象本地化字符串，object默認(rèn)的方法自身不做任何局部化，返回結(jié)果與toString()相同
hasOwnProperty(property) //object類的方法，判斷對象是否有某個非繼承屬性
propertyIsEnumerable(property) //object類的方法，屬性（非繼承）是否可用 For in枚舉
isPropertyOf(object) //object類的方法，判斷該對象是否為傳入對象的原型
}
JS高級編程 第三章： Function 函數(shù)、類、構(gòu)造函數(shù)、原型 Classes,Constructors,and Prototypes /**/↑↓←→
//JS的斷點(diǎn)： 在需要打斷點(diǎn)的地方寫上debugger ， 在遇到版本不能調(diào)試時很可能是調(diào)試被禁用了：打開IE 工具→Internet選項(xiàng)→高級→瀏覽（將禁用腳本點(diǎn)沒）
//上節(jié)課補(bǔ)充
{
<SCRIPT language="JavaScript“>
var a="3" , b="4";
alert (a+"+"+b ); //輸出的是： 3+4
alert (eval(a+"+"+b) ); //輸出的是： 7 eval("字符串"); eval()會將（）中的代碼進(jìn)行動態(tài)解析，把代碼解析成js腳本，不過盡量少用，因?yàn)榕掠袗阂饽_本入注
</SCRIPT>
}
//函數(shù)的定義（3種方法）
{
定義函數(shù)：
function 函數(shù)名( 參數(shù)1,參數(shù)2，… )
{
語句;
}
如果函數(shù)不包含return語句，返回undefined
var f = new Function("x", "y", "return x*y;"); //一般不用，效率太低
等同于：
function f(x, y) { return x*y; }
var f=function(x){return x*x}
函數(shù)直接量是一個表達(dá)式，他可以定義匿名函數(shù)/*匿名函數(shù)：函數(shù)在定義的時候沒有名字，而用一個變量接受*/
}
//函數(shù)的調(diào)用
{
調(diào)用函數(shù)：使用運(yùn)算符（）來調(diào)用它 ;
調(diào)用函數(shù)的注意事項(xiàng)
（1）不能給函數(shù)的參數(shù)指定一個函數(shù)類型
（2）JavaScript不會檢測傳遞的數(shù)據(jù)是不是那個函數(shù)所要求的類型
（3）也不會檢測傳遞給他的參數(shù)個數(shù)是否正確
}
//函數(shù)的遞歸
{
var a = function aa(b) { //aa是方便后面調(diào)用
if (b <= 1) {
return 1;
}
return b * aa(b - 1);
}
document.write(a/*或aa*/(5)); //相當(dāng)于：5*4*3*2*1 顯示120
}
//函數(shù)并不只是一種語法，還可以是數(shù)據(jù)
{
var aa = new Array(3);
aa[0] = function(x) {
return x * x;
}
aa[1] = 20;
aa[2] = aa[0](aa[1]);
document.write(aa[2]); //顯示：400
}
//做為方法的函數(shù)
{
var calculator={
num1:1, !注意是“，”!
num2:1,
compute:function(){this.result=this.num1+this.num2;} //calculator相當(dāng)于一個類 this.result相當(dāng)于函數(shù)自定義了一個屬性
};
//debugger
calculator.compute();
document.write(calculator.result,"<br />"); //顯示：2 //calculator.result可能點(diǎn)不出來
//this : 指向正在被調(diào)用的對象
function aa() {
return this.num11 * this.num22;
}
function bb(num1, num2) {
this.num11 = num1;
this.num22 = num2;
this.a = aa;
}
var b = new bb(2, 3); //要用一個變量接受一下，這個事例是模仿的類，所以就要像真正的類一樣用變量new一下然后才能點(diǎn)出
document.write(b.a()); //顯示：6
}
//Arguments
{
它是調(diào)用對象的一個特殊屬性，能夠計算出傳入方法時實(shí)際參數(shù)的個數(shù)，它不是數(shù)組但可以用數(shù)組的方式操作它
通過Arguments[]數(shù)組改變參數(shù)的值同樣會改變用參數(shù)名獲取的參數(shù)值
/*例子*/
function test(x,y,z) {
try
{
if (arguments.length != 3) {
throw new Error("未提供正確的參數(shù)個數(shù)"); //JS中的throw
}
else if (typeof (arguments[0]) != "number" || typeof (arguments[1]) != "number" || typeof (arguments[2]) != "number") {
throw new Error("參數(shù)類型錯誤");
}
else {
return x + y + z;
}
}
catch(exception) //exception沒有提示，硬打
{
document.write(exception.message); //exception.message也沒有提示
return ""; //不加return"";返回undefined
}
}
document.write(test(1,2,"3"),"<br />");
document.write(test(1));
document.write(test(1,3,5));
document.write("<br />");
function fun(x)
{
document.write(x+"<br />");
arguments[0]=null;//arguments[0] 命名參數(shù)x是引用同一變量的兩種不同方法
document.write(x);
}
fun(12);
/*顯示*/
12
null
}
//callee /*指向當(dāng)前正在被執(zhí)行的函數(shù)*/
{
function aa(x) {
if(x<=1) {
return 1;
}
return x + arguments.callee(x-1); /arguments.callee()指向的就是函數(shù)aa()/
}
document.write(aa(6)); /顯示：21（6+5+4+3+2+1）/
function aa(a, s, d) {
document.write(arguments.length+"<br/>"); //顯示： 1 //argument.length :實(shí)際參數(shù)的個數(shù)
document.write(arguments.callee.length + "<br/>"); //顯示： 3 //arguments.callee.length :形式參數(shù)的個數(shù)
document.write(aa.length); //顯示： 3 //函數(shù)名.length :形式參數(shù)的個數(shù)
}
aa(1)
}
//函數(shù)的方法
{
call() 方法
f.call(o, 1, 2); //將f綁定到o "1,2"是f執(zhí)行時需要的參數(shù)
這與下面的代碼相似：
o.m = f;
o.m(1,2);
delete o.m;
//call apply
{
function Add(x,y)
{
return x+y;
}
var o = new Object();
document.write(Add.call(o,1,2),"<br />"); //綁定后直接返回值
//類似于
//o.m=Add;
//o.m(1,2);
//delete o.m;
document.write(Add.apply(o,[1,2])); //給的是個數(shù)組，在但是在綁定時自動拆開 本事例的結(jié)果兩者相同
}
}
//模擬命名空間
{
if(typeof com=="undefined") //注意：undefined是字符串類型的要用“”
{
com=new Object(); //com前沒有var
}
if(typeof com.sitepoint=="undefined") //個人覺得沒什么用，可以用自己起的特別點(diǎn)的名字加_代替
{
com.sitepoint=new Object();
}
com.sitepoint.Bird=function()
{
this.feet=2;
this.feathers=true;
}
var tweety=new com.sitepoint.Bird();
alert("鳥有"+tweety.feet+"爪子");
}
//用new關(guān)鍵字創(chuàng)建對象
{
function Aa(w,h) //此示例模擬了一個類，this點(diǎn)出的方法做為本類的方法 注意：為了區(qū)分類和方法在命名時類的首字母要大寫
{
this.width=w; //width作為本類的屬性
this.heigh=h;
this.shuxing=function ()
{
return this.width*this.heigh;
}
}
var a=new Aa(12,12); //沒次new 都創(chuàng)建了一個新的對象，也重復(fù)創(chuàng)建了"shuxing"方法，浪費(fèi)內(nèi)存
var b=new Aa(2,2);
var c=new Aa(3,3);
var cc=a.shuxing();
document.write(cc);
}
//使用原型創(chuàng)建對象（調(diào)用prototype方法） //prototype：原型
{
function P(x, y)
{
this.x = x;
this.y = y;
this.total = function()
{
return this.x+this.y;
};
}
P.prototype.z = 10; //添加對象P的原型屬性 //用原型創(chuàng)建對象：原型對象或方法不在類中聲明，在類的下面用：類名.prototype.屬性名（或方法名）=值，聲明后的屬性和方法在調(diào)用時和普通屬性方法沒什么不同，只是在創(chuàng)建對象時不重復(fù)創(chuàng)建
P.prototype.total1 = function(x, y)
{ //添加對象P的原型方法
return x+y+1;
};
var t = new P(1, 2);
var t1 = new P(3,4);
t.z = 20; //動態(tài)添加屬性，在java這種強(qiáng)類型語言中是不可能的……
document.write(" total:"+t.total()+" total1:"+t.total1(1,3)+" z:"+t.z+"</br>");
document.write(" total:"+t1.total()+" total1:"+t1.total1(2,4)+" z:"+t1.z+"</br>");
/顯示/
total:3 total1:5 z:20
total:7 total1:7 z:10
}
//模擬類的繼承（call繼承）
{
function jilei(q,w)
{
this.qq=q;
this.ww=w;
this.ii=function ()
{
return this.qq*this.ww;
}
}
jilei.prototype.ee=function()
{
return this.qq+this.ww;
}
function zilei(r,t)
{
jilei.call(this,2,3); //綁定時用this代表本類
this.rr=r;
this.tt=t;
}
zilei.prototype.yy=function()
{
document.write(this.rr*this.tt);
return""; //指定返回值為空否則返回undefined
}
var jj=new zilei(4,5);
document.write(jj.ii()); //調(diào)用基類的方法不能點(diǎn)出只能硬打
document.write(jj.yy());
/顯示/
6
20
}
/例子/
『
function xing(bian)
{
this.bianshuxing=bian;
// this.jibianxing=function ()
// {
// document.write("這是一個"+this.bianshuxing+"形");
// }
}
xing.prototype.jibianxing=function()
{
document.write("這是一個"+this.bianshuxing+"形");
}
function san(di,gao)
{
xing.call(this,3);
this.d=di;
this.g=gao;
}
san.prototype=new xing(); //在繼承類的下面加上，讓子類能夠繼承基類的所有屬性包括原型方法
san.prototype.s=function()
{
document.write("三角形的底是:"+this.d+"三角形的高是:" +this.g+"面積是："+this.d*this.g/2);
}
function si(bian,bian3)
{
xing.call(this,4);
this.bian1=bian;
this.bian2=bian3;
}
si.prototype=new xing();
si.prototype.ss=function()
{
document.write("四邊形的一條邊為："+this.bian1+"四邊形的第二條邊為："+this.bian2+"面積是："+this.bian1*this.bian2);
}
debugger;
var sanj=new san(4,3);
sanj.jibianxing();
sanj.s();
var sibian=new si(7,8);
sibian.jibianxing();
sibian.ss();
』
//例子//
{
function xing(bian)
{
this.bianshuxing=bian;
this.jibianxing=function ()
{
document.write("這是一個"+this.bianshuxing+"形");
}
}
function san(di,gao)
{
xing.call(this,3);
this.d=di;
this.g=gao;
}
san.prototype.s=function()
{
document.write("三角形的底是:"+this.d+"三角形的高是:" +this.g+"面積是："+this.d*this.g/2);
}
function si(bian,bian3)
{
xing.call(this,4); //this : 指示的是正在運(yùn)行的程序，在類中是new出的類名指向的東東
this.bian1=bian;
this.bian2=bian3;
}
si.prototype.ss=function()
{
document.write("四邊形的一條邊為："+this.bian1+"四邊形的第二條邊為："+this.bian2+"面積是："+this.bian1*this.bian2);
}
debugger;
var sanj=new san(4,3);
sanj.jibianxing();
sanj.s();
var sibian=new si(7,8);
sibian.jibianxing();
sibian.ss();
/顯示/
{
`這是一個3形三角形的底是:4三角形的高是:3面積是：6這是一個4形四邊形的一條邊為：7四邊形的第二條邊為：8面積是：56
}
}
//不管用不用prototype方法創(chuàng)建，系統(tǒng)都會自動創(chuàng)建一個原型，里面有一個constructor對象，里面放的是一個指針，這個指針不隨著類new出的對象里的元素的變化而變化，它能指向自己的基類
『
/例子/
<script language="javascript" type="text/javascript">
function Student(sName)
{
this.name=sName;
this.displayName=function (){
alert(this.name);
}
}
function ZhangSan(sName,sAge)
{
this.method=Student;
this.method(sName);
delete this.method; //將delete this.method注釋了也能正常運(yùn)行，
zhangsan new 出的對象雖然把method刪除了，但是在new出的對象里面隨著類的實(shí)例化的同時系統(tǒng)自動創(chuàng)建了一個原型，里面有一個指向基類（student類）的指針，所以在調(diào)用基類的方法時雖然她的method已經(jīng)刪除還是能找到基類的方法
this.age=sAge;
this.displayAge=function (){
alert(this.age);
}
}
var s1=new Student("普通學(xué)生");
s1.displayName();
var zs=new ZhangSan("張三",23);
zs.displayName();
zs.displayAge();
</script>
相關(guān)文章
下面小編就為大家?guī)硪黄獪\談JavaScript 覆蓋原型以及更改原型。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨過來看看吧2016-08-08
這篇文章主要為大家詳細(xì)介紹了微信小程序?qū)崿F(xiàn)表單驗(yàn)證源碼，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-07-07
詳解js中構(gòu)造流程圖的核心技術(shù)JsPlumb（2）
這篇文章主要介紹了js中構(gòu)造流程圖的核心技術(shù)JsPlumb，jsPlumb是一個強(qiáng)大的JavaScript連線庫，它可以將html中的元素用箭頭、曲線、直線等連接起來，適用于開發(fā)Web上的圖表、建模工具等，需要的朋友可以參考下2015-12-12
javascript九宮格圖片隨機(jī)打亂位置的實(shí)現(xiàn)方法
這篇文章主要為大家詳細(xì)介紹了javascript九宮格圖片隨機(jī)打亂位置的實(shí)現(xiàn)方法，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-03-03
關(guān)于JavaScript中的this指向問題總結(jié)篇
在小編面試過程中經(jīng)常會遇到j(luò)avascript中this指向問題，可以說是前端面試必問，下面小編給大家總結(jié)了一下js中this的指向，感興趣的朋友一起學(xué)習(xí)吧2017-07-07
遍歷所有樣式屬性，通過判斷其屬性值，是否為'undefined' 或特特的值，來過慮屬性2012-09-09
這篇文章主要教大家學(xué)習(xí)使用Bootstrap頁面排版樣式，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-05-05
layui使用及簡單的三級聯(lián)動實(shí)現(xiàn)教程
這篇文章主要給大家介紹了關(guān)于layui使用及簡單的三級聯(lián)動的實(shí)現(xiàn)方法，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-12-12
基于JavaScript實(shí)現(xiàn)一個簡單的Vue
這篇文章主要介紹了基于JavaScript實(shí)現(xiàn)一個簡單的Vue的方法，本文通過實(shí)例代碼給大家介紹的非常詳細(xì)，具有一定的參考借鑒價值,需要的朋友可以參考下2018-09-09
記錄我看到之后，不得不贊的代碼片段。本貼板內(nèi)容將不斷更新，歡迎關(guān)注2013-06-06