表達式和運算符
表達式：表達式用於JavaScript腳本運行時進行計算的式子，可以包含常量、變量、運算符
運算符：操作數據值的操作符
算術運算符：+、-、*、/、%
一元運算符：++、--
......
算符運算符
1.+
1.如果兩個操作符都是數值，執行常規的加法計算
2.如果有一個操作數是字符串，規則如下：
1.如果兩個操作數都是字符串，將兩個操作數拼接
2.如果只有一個操作數是字符串，則將另一個數轉換成字符串，再將兩個字符串拼接起來
3.如果有一個操作數是對象、數值、Boolean，則需要調用他們的toString（）方法取得相應的字符串值
注意：
Undefined /null調用string（）方法將其轉換成“Undefined”、“null”
2.-
1.如果兩個操作數都是數值，進行常規的減法，並返回結果
2.如果有一個操作數是字符串、Boolean、null/Undefined則需要調用number()函數將其轉換成數值，根據前面的規則進行減法
注意：
如果轉換的結構是NaN，減法的結果就是NaN
3.如果操作數是一個對象，則調用對象的valueOf()方法取得表示該對象的數值
1.如果值爲NaN，減法的結果解釋NaN
2.如果對象沒有valueOf（）這個方法，則調用toString（）方法將得到的字符串轉成數值，在進行常規計算
3.*
基本：
1.如果操作數都是數值，進行常規計算
1.1 如果兩個都是正數，結果是正數
1.2 如果只有一個有操作符號，那麼結果爲負數
1.3 如果乘積成果了ECMAScript數值的表示範圍，返回Infinity或者-Infinity
特殊的規則：
1.如果操作數爲NaN，結果爲NaN
2.如果是Infinity和0相乘，結果爲NaN
3.如果Infinity與非0數值相乘，結果爲Infinity或負Infinity，取決於有符號操作數的符號
4.如果Infinity和Infinity相乘，結果爲Infinity
5.如果操作數不是一個數值，則需要調用number()方法將其轉換成數值，在進行上面的規則
4./
特殊：
1.如果零被零除，結果爲NaN
2.如果有一個非零的有限數被零除，結果爲Infinity和-Infinity，取決於有符號操作符的符號
5.%
var result=26%5;//1
1.如果操作數都是數值，執行常規除法計算，返回除得的餘數
2.如果被除數是無窮大而除數是有限大的數值，結果爲NaN
3.如果被除數是有限大的數值而除數爲0，結果爲NaN
4.如果Infinity被Infinity除，結果爲NaN
5.如果被除數是有限大的數值而除數是無窮大的數值，結果爲被除數
6.如果被除數爲0，結果爲0；
7.如果有一個操作數不是數值，在後臺調用Number()方法，將其轉換成數值，在進行上面的運算
一元運算符
1.只能操作一個值的操作符叫做一元運算符
2.自增++
自減--
在賦值操作時，
1.1 如果遞增或遞減運算符前置，那麼前置的運算符會先累加或累減在賦值
1.2 如果遞增或遞減運算符後置，那麼後置運算符則先賦值在累加或累減
如：
var box=100;
var age=++box; 101
var height=box++; 100
3.其他類型應用一元運算的規則
var box='89'; box++ 數值字符串自動轉換成數值 //90
var box='ab'; box++ 字符串包含非數值轉成NaN 、//NaN
var box=false; box++ false轉成0， 1
var box=2.3; box++ 直接加1， 3.3
例如：
var a=9;
var b=++a;
a=a+1;
alert(a+" "+b)
賦值運算
1.定義：將右邊的值賦給左邊的變量
2.複合操作;+=、-=、*=、/=、%=
如：
var num=10;
num=num+10 等價於num+=10;
比較運算符
1.比較運算符的結果Boolean類型（>、>=、<、<=）
2.當關系操作符的操作數使用了非數值，需要進行數據轉換，完成相對應的功能
1.1 如果兩個數都是數值，則執行數值比較
1.2 如果兩邊都是字符串，比較的是字符串對應的字符編碼值
1.3.如果一個操作數是數值，則將另一個操作符轉換成數值，進行比較
1.4 如果一個操作數是對象，則需要調用對象的valueOf（）方法，如果沒有則調用toString（），將得到的結果根據前面的規則進行比較
1.5 如果一個操作數爲Boolean類型，需要將其轉換成數值，在進行比較
等於==規則
1.如果兩個類型相同，進行==比較
2.如果操作數爲非數值，需要遵循以下規則：
1.1 一個操作數爲Boolean，比較前需要將其轉換爲數值類型 false：0 true：1
1.2 一個操作符爲字符串，先轉成數值類型在比較
1.3 一個操作符爲對象，則現代用valueOf（）、toString（），將返回值進行比較
1.4 在不需要任何轉換的情況下,null / Undefined 是相等的，
注意：這兩個值在進行比較時，不能進行類型轉換
1.5 一個操作數爲NaN，則==返回false != 返回true 和自身不等
恆等於===的規則
1.如果類型不相同，就不相等
2.如果兩個都是數值，並且是同一個值，那麼相等
注意：
2.1 如果其中至少一個NaN，那麼就不相等，判斷一個值是否是NaN，用isNaN()方法
3.如果兩邊都是字符串，每個位置的字符都相等，那麼相等，反之不相等
4.如兩邊的值爲true 或 false 則相等
5.如果兩邊的值都引用同一個對象或函數，那麼相等
6.如果兩邊的值爲null或者undefined 那麼相等
其他的運算符
typeOf運算符
typeOf運算符用來返回一個字符串，返回的是操作數的數據類型
對一個值使用typeOf 操作符可能返回字符串
1.“Undefined” 該值沒有定義
2.“Boolean” 該值是Boolean值
3.“string” 該值是字符串
4.“number” 該值是數值
5.“Object” 該值是一個對象或者null
6.”function“ 該值是一個函數
邏輯運算符
邏輯非！
邏輯非操作符遵循以下規則：
1.如果操作數是一個對象 ，返回false
2.空字符串 true 反之爲false
3.數值爲0，返回 true
4.任何非0（包括Infinity） 返回false
5.null 返回true
6.NaN true
7.undefined true
邏輯與&和&&（短路）
第一個操作數 第二個操作數 結果
true true true
false true false
true false false
false false false
2.邏輯與操作可以應用於任何類型的操作數，而不僅僅是Boolean，在一個操作數不是Boolean類型的情況，邏輯與就不一定返回Boolean
遵循以下規則：
1.如果第一個操作數爲對象，則返回第二個操作數
2.如果第二個操作數是對象，則只有第一個操作數的求值結果爲true的情況下才會返回該對象
3.如果兩個操作數都是對象，則返回第二個操作數
4.有一個操作數爲null，返回null
5.如果有一個操作數爲NaN，返回NaN
6.如果有一個操作數爲Undefined則返回Undefined
邏輯或|和||（短路）
第一個操作數 第二個操作數 結果
true true true
false true true
true false true
false false false
特殊規則：
1.如果第一個操作數爲對象，則返回第一個操作數
2.如果第一個操作數的求值結果爲false，則返回第二個操作數
3.如果兩個操作數都是對象，則返回第一個操作數
4.有兩個操作數爲null，返回null
5.如果有兩個操作數爲NaN，返回NaN
6.如果有兩個操作數爲Undefined則返回Undefined
三目運算符
稱之爲條件運算符是ECMAScript中功能最多的運算符
他的形式和Java中一樣
variable=boolean_ex?true:false;
例如：
var iMax=(iNUm1>iNUm2)?iNUm1:iNum2;
條件語句
1.語句
2.條件語句
3.if語句
4.switch語句
語句
定義：
ECMA規定一組語句（流程控制語句）
語句定義了ECMAScript中主要的語法
條件語句：
1.if語句
2.switch語句
循環語句：
1.while循環語句
2.do...while語句
3.for循環語句
條件語句
概念：
通過制定判斷的表達式的值來決定執行還是跳過某些語句
這些語句是代碼的決策點，稱之爲“分支”
第一種格式：
if(條件){
//代碼塊
}
當代碼塊只有一條語句時，可以省略大括號
這其中的條件可以是任何的表達式，計算的結果不必是Boolean，ECMAScript，會將其轉換成Boolean值
第二種：
if（條件）{
//代碼塊1
}else{
//代碼塊2
}
第三種：
多重if語句
if（條件）{
//代碼塊1
}else if(條件){
//代碼塊
}
else{
//代碼塊2
}
第四種：
嵌套if
if(條件){
if(條件){
//代碼塊
}
}
switch語句
switch語句的語法：
switch ()
case value: statement;
break;
case value: statement;
break;
default :statement
特點：
1.可以在switch語句中使用任何類型的數據
每一個case的值不一定是常量，可以是變量，表達式
2.每個case按照順序被求值，直到找到匹配的值或者遇到default語句爲止
3.在比較時會使用全等操作符，因此不會發生類型轉換（字符串“10”和數值10 不相等）
4,default可以省略
5.break可以省略，穿透
共同點：在一定程度上可以通用
if和switch區別：
1.if一般用於區間、邏輯判斷
switch多用於等值比較
2.if使用時嵌套儘量少用，
循環語句
1.循環語句
2.特殊流程控制語句
3.二重循環語句
4.label語句
循環的四個部分：
1.循環變量初始化
2.循環判斷條件
3.循環體
4.迭代部分（循環變量增加或減少的處理）
while循環語句
格式：
循環變量的初始化：
while(詢函條件){
循環操作；
迭代語句；
}
do..while循環
格式：
循環變量的初始化；
do{
循環操作；
迭代語句；
}while（循環條件）；
do...while和while的區別：
1.do....while至少執行一次
2.do...while（表達式）的後面一定要有一個分號，用來表示語句的結束
for循環
格式：
for(var box=1;box<=5;box++){
alert(box);
}
循環順序：
1.聲明變量var box=1;
2.判斷條件
3.執行語句體
4.判斷循環條件
加強for
格式：
for(vriable in object){
statement
}
說明：
vriable：通常是一個變量名或表達式或者是var 聲明的變量
object：表達式，計算結果是一個對象
通常用枚舉對象的屬性
特殊流程控制語句
1.break：
2.continue
label語句
語法：
標籤名：for(表達式1；表達式2；表達式3){
break 標籤名；
或者continue 標籤名
}
例如：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<script type="text/javascript">
for(var i=0;i<5;i++){
bk:
for(var j=0;j<5;j++){
if(i==1&&j==1){
break bk;
}
document.write(i+" "+j+"<br/>")
}
}
</script>
</body>
</html>
總結：
for循環、while循環、do...while循環、for-in
1.可以相互轉換
2.可以相互嵌套
3.特殊流程控制語句，可以在其使用
4.循環中可以嵌套分支語句，分支語句也可以嵌套循環
函數
函數的概念和作用
1.概念：函數就是把完成特定功能的一段代碼封裝起來，給該功能起一個名（函數名）
注意：函數可以在任何地方調用
2.作用：
1.使程序變得更簡潔和清晰
2.便於維護
3.可以提高程序的開發效率
4.提高了代碼的重用性
說明：
不使用函數，JavaScript代碼必須執行，且執行的時間，執行的部分不可控，使用函數後瀏覽器不會直接去執行它，只有在調用該函數時纔會被瀏覽器執行
函數的分類
1.官方定義函數：
alert（）;
parseInt();
parseFolat();
isNaN();
2.自定義函數：
用戶根據自己的需求定義的函數
函數的命名規範
1.函數名不能包含特殊字符
2.函數名最好含義明確
3.函數名稱最好遵循駝峯標記法或者下劃線法
4.函數名嚴格區分大小寫
5.函數名如果產生重複會覆蓋
函數的定義
格式：
1.無參數：
function 函數，名(){
js代碼；
}
2.有參數
function 函數名（形式參數列表）{
js代碼；
}
3.匿名函數
function（）{
js代碼；
}
4.有返回值的函數
function 函數名(形式參數列表){
js代碼；
return 返回值；
}
總結：
1.函數需要使用function關鍵字，必須寫
2.函數名---標識符，
3.參數列表只有變量名，沒有var關鍵字
無參函數
只有一個參數
有多個參數
4。{函數體}：
1.有返回值的函數
2.沒有返回值的函數
函數的實參和形參
1.實參和形參：
形參---就是函數在定義時，函數名後面的參數，不能使用var關鍵字
實參---就是調用時，函數名後面的參數
2.傳參---賦值：將實參的值賦給形參
3.JavaScript語言的特殊之處：
1.不檢查實參的類型，不檢查形參的個數
JavaScript語言與大多數語言在函數參數上是不一樣
JavaScript語言不在乎你傳入參數的個數和類型
在JavaScript每個函數的函數體重都有一個arguments對象來訪問這個函數的參數，從而獲取所有傳過的參數
4.JavaScript語言可以傳入任意多個參數
函數參數的類型
1.值類型的數據作爲參數傳遞的時候，相當於操作值的副本
2.引用傳遞操作的是參數本身
例如：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<script type="text/javascript">
var a=3,b=5;
var c=a; //a:3 b;5 c:3
a=b; // a=5
b=c; //b:3
//實現兩個變量值交換的方法
//a,b就是形式參數，代表兩個數據
function change(arr){
var c=arr[0];
arr[0]=arr[1];
arr[1]=c;
}
var people=new Object();//people 是對象 引用類型
people.name=“李四”;
change(people);
</script>
</body>
</html>
函數的返回值
函數的返回值可以返回：
number string boolean null undefined object
注意：
當函數沒有返回值時，其實返回值爲undefined
例如：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<script type="text/javascript">
/*var flag=confirm("確定刪除嗎？");
alert(flag);
var a=alert("dgshj")
*/
/* function test(a,b){
var result=a-b;
return result;//注意return 只能在函數中使用，代碼執行到return就結束這個函數
}
var num=test(3,5);
alert(num);*/
//求三個數的最大值
function getMax(a,b,c) {
//用return把參數不是數值的情況給排除，並返回提示信息
if (typeof(a) != "number" || typeof(b) != "number" || typeof(c) != "number")
{
return "參數必須都是數字";
}
var max=-Infinity;
var min=Infinity;
if(a>max){
max=a;
}
if(b>max){
max=b;
}
if(c>max){
max=c;
}
if(a<min){
min=a;
}
if(b<min){
min=b;
}
if(c<min){
min=c;
}
return "最大值："+max+",最小值："+min;
}
alert(getMax(21,40,-4));
</script>
</body>
</html>
函數的調用
1、函數名（參數）調用
1.1 通過函數名（）進行調用，如果有參數產地相對應的參數即可
1.2 在HTML中默認的全局對象是HTML頁面本身，所以函數是屬於HTML頁面，在瀏覽器中的頁面對象是瀏覽器窗口（window對象）
2.事件驅動：
所有的函數沒有調用不會執行，那麼函數調用的源頭就是事件，之前學過點擊事件onclick
成爲焦點onfocus 失去焦點 onblur
3.如：window.函數（參數）：
注意：
1.在函數體內可以調用另外一個函數
2.函數可以自己調自己（遞歸）
全局對象：
1.當函數沒有被自身對象調用時，this的值就變成全局對象
在web瀏覽器中全局對象是窗口對象（window對象）
2.函數作爲全局對象的調用，會使this,window對象成爲全局對象，會使程序容易崩潰
注意對象：
1.函數可以有一個或多個參數，也可以沒有
2.函數可以通過return加返回值，如果沒有return，默認返回undefined
3.函數不調用不執行
4.JavaScript對大小寫敏感，關鍵字function 必須小寫
，並且必須與函數名相同的大小寫來調整函數
變量的作用域
定義：變量起作用的範圍，變量的有效範圍
局部變量：在函數內部的變量，形參也是局部變量
全局變量：在函數外部的變量，作用域範圍是當前文件的任何地方
說明：
1.JavaScript的變量的作用域是根據方法塊來劃分的，也就是function的大括號來劃分的
注意：function塊是劃分標準，而for/while並不是作用域的劃分標準
2.JavaScript在執行前會對整個腳本文件的聲明部分做完整的分析（包括局部變量），從而確定實變量的作用域
3.當全局變量跟局部變量重名時，局部變量的作用域會覆蓋全局變量的作用域
4.全局變量位於全局區，局部變量位於棧區
匿名函數
定義函數的兩種格式：
1.function 函數名(){
//函數體
}
2.匿名函數
var fun=function()
{
//函數體
}
匿名函數的用處：
1.函數表達式可以儲存在變量中，變量可以作爲一個函數使用，也可以將匿名函數作爲參數傳遞給其他函數，
如果需要完成一次性的任務，可以用匿名函數
函數的重載
定義：
重載函數時函數的一種特殊情況
：允許在同一個範圍內聲明幾個功能類似的同名函數，但是這些同名函數的形式參數（指參數的個數或類型或順序）必須不同，也可以說同一個運算符完成不同的運算功能，稱之爲重載函數
1.函數有不同的參數
2.函數有不同的參數類型
但是在JavaScript語言中，如果函數名一樣會出現覆蓋的情況，無法實現函數的重載
JavaScript並沒有重載函數的功能，但是arguments對象可以模擬重載
JavaScript中每個函數都會有一個arguments對象實例arguments,他引用着函數的實參，可以用數組的下標方式“[]”引用arguments的元素
arguments.length爲函數實參的個數
arguments.callee引用函數自身
arguments
定義：
arguments對象不能顯示創建，只有函數開始時纔可用
函數的arguments對象並不是一個數組，訪問單個參數的方式與訪問數組元素的方式相同
索引n實際就是arguments對象的0~n屬性的其中一個參數。
注意：
1.arguments的length屬性返回調用程序傳遞給函數的實際參數數目
2.arguments的0~n屬性返回一個arguments對象中的各個參數的實際值，相應的值由一個正在執行的函數的arguments屬性返回
遞歸
定義：在函數體內調用本函數
遞歸的滿足條件：
1.函數自己調用自己
2.要有出口
3.儘量層層遞進
注意：
處理不當就如死循環，遞歸函數只有在特點的情況下使用
數組
1.數組定義：
值的有序集合，美譽個值都叫做一個元素，每一個元素在數組中都有一個位置，以數字表示，叫索引
特點：
1.JavaScript數組是無類型的，數組的元素可以是任意類型，並且同一個數組中的元素可以是不同類型，
2.ECMAScript語言中數組的長度是可以動態變化的，可以添加和刪除元素
3.Array數組是數據的有序列表，索引從0開始
4.ECMAScript同一個數組可以存儲不同類型的數據，也可以沒有類型，但每一個數組都有length屬性
數組的創建
1.數組字面量方式：
//創建3個字符串的數組
var aColor=["red","yellow","blue"]；
//創建空數組
var aColor=[];
var aColor=[1,2,3,];
bug:
在IE8以及之前顯示的個數爲4個
IE9,ff,chrome,opera中顯示是3個，不要用這種方式去創建數組
注意：
省略數組中的某個值，默認值爲undefined
2.構造函數方式：
//創建一個空函數
var aColor=new Array();
//創建一個容量爲20 的數組
var aColor=new Array(20);
//創建一個包含3個字符串元素的數組
var aColor=new Array("red","yellow","blue");
注意：
1.最後一個元素不可以加逗號，會報語法錯誤
2.使用構造函數法創建數組時，如果只傳一個值，這個值是number類型，那麼必須是大於等於0的整數，否則語法報錯
3.使用構造函數創建數組時，可以省略new關鍵字（不建議）
數組的長度
length屬性：表示數組的長度
不同：
JavaScript數組的length屬性是可變的，
1.當length被設置的更大時，整個數組的狀態事實上不會發生變化，僅僅是length屬性值變大
2.當length屬性被設置的比原來更小時，則原先數組中國索引大於或等於length元素的值會全部丟失
3.length屬性不僅可以被顯示設置，他也可以被隱式修改
注意：
1.數組的length屬性不是隻讀的，可以通過數組的length屬性向數組的末尾擴大數組的容量，或者可以從數組的末尾移除其他元素
數組的遍歷
定義：獲取數組中的每一個元素
1.for循環
for(var i=0;i<arr.length;i++){
//代碼塊
}
2.加強for循環
for (var i in arr){
//代碼塊
}
3.forEach：是對數組中每一個元素進行函數體的操作
是ECMAScript5.0新特性
注意：forEach不支持break/continue語句
在低版本的IE中也無法使用
數組中的常用方法
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>demo</title>
</head>
<body>
<script type="text/javascript">
var arr=["21sd",23,6,0,-2];
var str=arr.join("///");
//1.join(連接符字符串)，無參的時候默認使用“，”鏈接，返回值時連接後的字符串，操作對數據並沒有影響
//alert(typeof str+" "+str);
//alert(arr);
var arr2=str.split("///");
var s="abc13";
// 2. arr2=s.split("");
//alert(arr2);
//要在頁面輸入一個用戶名，判斷這個用戶名是否全部由字母組成
//數組元素倒置，返回倒置之後的結果，該倒置度數組本身有影響reverse()
// alert(arr.reverse());
//alert(arr);
//3.sort() 返回排序之後的結果，對齊數組本身有影響
// 3.1 sort()無參，按照字符的先後順序排序
// 3.2 sort()有參 參數必須是一個函數
//var arr2=[11,22,3,4,56,-54353,555]
//arr2.sort(test)
//alert(arr2);
// function test(a,b) {
// return a-b;
// }
//4.concat();參數可以是任意類型，表示吧參數都鏈接到原數組上，返回新的數組，該鏈接對原數組並沒有影響、
//參數是一個數組時，則將數組中的元素鏈接到原始數組上
//alert(arr.concat(111,"哈哈哈"));
//var newArr=arr.concat([false,true]);
//alert(newArr[5]);
/*5.slice():
1.slice():返回值是截取數組的一部分，截取對原數組無影響
2.slice()：只有一個參數的時候是起始下標，表示當前的位置一致截取到最末尾
3.slice()：如果有兩個參數，第二個參數表示終止下標，截取時會包含起始下標上的字符，不包含終止下標上的字符
注意：
如果下標爲負值，責先講該負值+length獲取一個正值，在截取*/
//alert(arr.slice(2,2))
//alert(arr.slice(1,3));
/* 6.splice():返回值爲刪除掉的元素組成的新數組，刪除會對原數組產生影響，數組的長度也會收到影響
splice()：第一個參數表示起始下標，負值責+length在作爲起始下標
第二個參數表示要刪除元素的個數，如使負值等同於0；
之後的參數表示要插入的數據，如果該方法只有一個參數，表示從起始下標一直刪除到末尾
*/
// alert(arr.splice(-2,2,false,true,"ddd"));
/*var arr3=[1,3,2,5,2,65,1,2,3,3,3,3];
for(var i=0;i<arr3.length;i++)
{
for(var j=i+1;j<arr3.length;j++){
if(arr3[j]==arr3[i]){
arr3.splice(j,1);
}
}
}
alert(arr3);*/
/*7.push():項數組的末尾追加元素，返回追加元素後數組的長度，
參數可以是一個或多個，表示要追加的數據，追加對原數組產生影響*/
//alert(arr.push(false,true));
//alert(arr);
// 8.pop():表示從數組的末尾往外彈出數據
//alert(arr.pop());
//9.map();
// var arr=[1,2,3,5,7];
// var newArr=arr.map(function (x,index,ar) {
// return x%2;
// })
//10.filter():
//11.reduce
//12.some();
/* 13.indexOF():在一個數組中查找子元素，若存在，返回該元素的下標，若不存在則返回-1；
注意：
indexOF()：從左到右查找，並且只查找一次*/
var arr=[1,4,"dsdf",true,"呵呵呵",-234,3];
//alert(arr.indexOf(5));
// 13.lastIndexOf（）：從末尾開始查找
var result=arr.lastIndexOf(3);
alert(result);
14.unshift();向數組的頭部插入一個或多個元素，
參數：需要插入的值
返回值：新數組的長度，會改變原來數組的長度
</script>
</body>
</html>
數組排序
冒泡排序
1.比較相鄰的元素，如果第一個比第二個大，就交換他們兩個
2.對每一個相鄰元素做同樣的工作，從開始的第一對到結束的最後一對
選擇排序：
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>demo</title>
</head>
<body>
<script type="text/javascript">
var arr=[2,5,0,-1,6];
for(var i=0;i<arr.length-1;i++)
{
for(var j=0;j<arr.length-1;j++){
if(arr[j]>arr[j+1]){
var temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
for(var i=0;i<arr.length;i++){
var max=arr[i];
var index=i;
for(var j=i+1;j<arr.length;j++){
if(arr[j]<max){
max=arr[j];
index=j
}
}
}
function text(a,b) {
if(a>b){
return -1;
}else if(a<b){
return 1;
}else {
return 0;
}
}
arr.sort(text);
alert(arr);
</script>
</body>
</html>
