可以在同一個頁面中引入多個.js文件，瀏覽器按照順序依次執(zhí)行

script標簽的 src 表示要引入的外部文件 ，type 表示腳本語言的類型（現(xiàn)代瀏覽器默認type="text/javascript"），所以script標簽可以不寫type

注釋是給開發(fā)人員看到，JavaScript引擎會自動忽略。
行注釋：

// 這是一行注釋 

塊注釋:
塊注釋是用/.../把多行字符包裹起來，把一大“塊”視為一個注釋

/* 
塊注釋
塊注釋
 */

文檔注釋:

/* 
 * 文檔注釋
 *文檔注釋
 */

標識符就是一個名字。在javascript中，標識符常用于定義變量名和函數(shù)名等。

命名規(guī)范：
1.在javascript中，標識符由字母,下劃線_和美元符$，數(shù)字組成
2.標識符不能以數(shù)字開頭
3.標識符區(qū)分大小寫：age和Age是不同的標識符，不建議代碼里出現(xiàn)用大小寫區(qū)分不同的標識符
4.變量名或者函數(shù)名的標識符不能使用關鍵字或保留字。
5.命名盡量遵守駝峰原則:personInfo,personName,personAge,

關鍵字：

break  case  catch  continue  default  delete  do  else  finally  
for  function  if in  instanceof  new  return  switch  this  
throw  try  typeof  var  void  while  with

保留字：

abstract    enum    int    short  boolean    export    interface    
static byte    extends    long   super   char    final    native    
synchronized  class    float    package    throws  const    goto    
private    transient   debugger    implements    protected    
volatile    double    import    public

語句指的是程序執(zhí)行行為的單元，每個語句以分號";"結(jié)束。
語句結(jié)束的分號可以不寫，瀏覽器解析會自動添加，但建議都加上。

下面是一個完整的賦值語句：
var x = 1; 

var y = 1; var sum= 2; // 不建議一行寫多個語句!，不美觀

塊由左花括號開始，由右花括號結(jié)束 {...}。
塊的作用是使語句序列一起執(zhí)行。
語句塊是一組語句的集合。例如下面{...}中的所有語句組成語句塊。

var x=10;
var y=20;
var sum=0;
 {  x=x+5;
    y=y+10;
    sum=x+y;
}

用關鍵字 var（variable） 聲明一個變量或常量（用于存儲數(shù)據(jù)的容器）

例如：var x; //聲明一個變量,變量名為x
      var x,y; //可以一次聲明多個變量，變量名用逗號分隔；

常量名習慣用大寫字母表示
常量的值不會通過再賦值改變，也不會再次聲明,通常在初始化的時候被賦值。

var SEX="男"; 

變量就是可以改變的量，變量的值會通過再賦值改變，也可以再次聲明和賦值。

例如：

// 先聲明，后賦值
var x;
x=1;

// 聲明的同時進行賦值
var x=2;

// 同時聲明多個變量用逗號（ ,）分開
var x,y,s;
x=1;
y=2;
s=3;
// 同時聲明和賦值多個變量，用逗號（ ,）分開
var x=1,y=2,s=3;  

表達式是javascript中的一個短語，表達式指的是可用于計算的式子，即可能產(chǎn)生一個值的式子。
變量名也是一種簡單的表達式，它的值就是賦值給變量的值。 復雜的表達式由簡單表達式和運算符組成。

例如：

var x=15;      //表達式x的值是15
var y=20;      //表達式的值是20
var sum=x+y;   //表達式x+y的值的35

編程語言最基本的特性就是能夠支持多種數(shù)據(jù)類型

數(shù)據(jù)類型分類

Number：數(shù)字（整數(shù)int，浮點數(shù)float）  
String：字符串
Boolean: 布爾類型  
特殊數(shù)據(jù)類型 Null、Undefined
Object：對象
Array：數(shù)組對象 
Function ：函數(shù)對象

typeof 操作符返回數(shù)據(jù)類型：

typeof 操作符:
用來檢測變量的數(shù)據(jù)類型, 對于值或變量使用 typeof 操作符會返回  
  如下字符串:
  1.Undefined數(shù)據(jù)類型的值為: 
    var a; console.log(typeof a); //undefined 未定義
  2.Boolean數(shù)據(jù)類型的值為: 
    var a=true; console.log(typeof a); //boolean 布爾值  
  3.String數(shù)據(jù)類型的值為: 
    var a="hello world"; console.log(typeof a); //string 字符串  
  4.Number數(shù)據(jù)類型的值為: 
  var a=1314; console.log(typeof a);  //number 數(shù)字  
  5.Object數(shù)據(jù)類型的值為: 
    var a=null; console.log(typeof a); //object null  
    var b={ }; console.log(typeof b); //object 對象 
  6.Function數(shù)據(jù)類型的值為: 
    var a=function () {}; console.log(typeof a); //function 函數(shù)

Number

Number 數(shù)字類型包含兩種數(shù)值：整型和浮點型
合法的數(shù)字類型Number類型：
整型:

var b = 100;  
console.log(b);
console.log(typeof  b);  

浮點類型: 就是該數(shù)值中必須包含一個小數(shù)點，并且小數(shù)點后面必須至少有一位數(shù)字

var b = 3.8;
var b = 0.8;
var b = .8; //有效，但不推薦此寫法

由于保存浮點數(shù)值需要的內(nèi)存空間比整型數(shù)值大兩倍，因此 ECMAScript
會自動將可以 轉(zhuǎn)換為整型的浮點數(shù)值轉(zhuǎn)成為整型。

var a = 8. ;  console.log(a);     //小數(shù)點后面沒有值，轉(zhuǎn)換為 8
var b = 12.0 ;  console.log(b);  //小數(shù)點后面是 0，轉(zhuǎn)成為 12

對于那些過大或過小的數(shù)值，可以用科學技術法來表示(e 表示法)。用 e 表示 該數(shù)值的前面 10 的指數(shù)次冪。

var box = 4.12e9 ?         //即 4120000000
var box = 0.000000124;    //即 1.24e-7

浮點數(shù)值的范圍在：Number.MIN_VALUE ~ Number.MAX_VALUE 之間, 如果 數(shù)值超過了JavaScript的Number所能表示的最大值或最小值，那么就先出現(xiàn) Infinity(正無窮)或-Infinity(負無窮)。

var num=12/0  // Infinity
var num=-12/0 // -Infinity

NaN, 即非數(shù)值(Not a Number)是一個特殊的值 ,當無法計算結(jié)果時用NaN表示

var b = 0/0 ; //NaN

ECMAScript 提供了 isNaN()函數(shù)，用來判斷這個值到底是不是 NaN。如果是返回true，如果不是返回false

console.log(isNaN(NaN));  //true
console.log(isNaN(25));   //false，25 是一個數(shù)值
console.log(isNaN("25"));  //false，"25"是一個字符串數(shù)值，可以轉(zhuǎn)成數(shù)值
console.log(isNaN("Lee")); //true，"Lee"不能轉(zhuǎn)換為數(shù)值
console.log(isNaN(true));  //false true 可以轉(zhuǎn)成成 1

數(shù)值的轉(zhuǎn)換

1.parseInt()    是把string類型或number類型的數(shù)據(jù)轉(zhuǎn)換為整型  
parseInt("10.898797");       //返回 10
parseInt(10.898797);  //返回 10

2.parseFloat()  是把string類型或number類型的數(shù)據(jù)轉(zhuǎn)換為浮點型（小數(shù)）
parseFloat("10.898797");     //返回 10.898797
parseFloat("10.898797");     //返回 10.898797

3.Number.toFixed(x) 把數(shù)字轉(zhuǎn)換為字符串，返回數(shù)據(jù)小數(shù)點后有x位數(shù)字
var num = 5.56789;  
var n=num.toFixed(2);  //"5.57"  四舍五入

4.Number.toPrecision(x)  把數(shù)字轉(zhuǎn)換為字符串,返回數(shù)據(jù)長度為x
var num = 13.3714;  
var n=num.toPrecision(3);    //"13.4"  四舍五入


5.Math.round四舍五入
Math.round(3.15) //3
Math.round(3.65) //4

6.Math.ceil 向上取整
Math.ceil(3.15)  //4
Math.ceil(3.65) //4

7.Math.floor向下取整
Math.floor(3.15) //3
Math.floor(3.65)  //3

String

String字符串類型,表示一串字符,可以由雙引號（" "）和單引號（" "）表示。

var str="hello" ;
var str="world" ;
請注意，""或""本身只是一種表示方式，不是字符串的一部分，因此，字符串"hello"只有h，e，l,l,o這5個字符。

Boolean

Boolean 布爾類型只有兩個值：true（真）和 false（假）。
而true一般等于1，false一般等于0。
JavaScript 是區(qū)分大小寫的，True和False或者其他都不是Boolean類型的值。

var flag=true;
console.log(typeof flag); //boolean

可以使用轉(zhuǎn)型函數(shù) Boolean(),將一個值轉(zhuǎn)換為其對應的 Boolean 值

var a = "Hello World!";  
var b = Boolean(a);  
console.log(typeof   b); 

Boolean 類型的轉(zhuǎn)換規(guī)則: (牢記)

String:        非空字符串為true        空字符串為false  
Number:        非0數(shù)值為true           0或者NaN為false  
Object:        對象不為null則為true    null為false  
Undefined :    undefined為false

Undefined

Undefined 類型的值只有一個，就是undefined。當一個變量被聲明，但未被賦值時，它的值就是undefined,代表未定義。

var num;
console.log(typeof num); //undefined
//注意: 我們在定義變量的時候， 盡可能的不要只聲明，不賦值, 而是聲明的同  時初始化一個值。

Null

Null 類型的值只有一個，就是 null。null表示一個空的對象。 typeof 操作符檢測 null 會返回 object。

var b = null;      console.log(typeof   b); //object

undefined 是派生自 null 的，因此 ECMA--262 規(guī)定對它們的相等性測試返回 true, 表示值相等。

console.log(undefined == null);   //true

但是兩者的數(shù)據(jù)類型是不一樣的

var b ; var car = null;
console.log(typeof b== typeof car)     //false

如果定義的變量準備在將來用于保存對象，那么最好將該變量初始化為 null 而不是其他值。

var obj=null;
obj={}

對象

JavaScript自定義對象對象是用花括號分隔,由一組由鍵(屬性名)-值(屬性值)組成的無序集合，屬性由逗號分隔，例如：

var obj = {
    name: "jack",
    age: 18
};

JavaScript對象的鍵(屬性名)和值(屬性值)組成。
屬性名是一個有效的變量名，可以通過.操作符來訪問屬性。
如果屬性名包含特殊字符，就必須用""或者""括起來，訪問這個屬性也無法使用.操作符，必須用["xxx"]或者["xxx"]來訪問。

屬性值可以是任意的數(shù)據(jù)類型。

訪問對象屬性的兩種方式

var name=obj.name;
var age=obj["age"];

數(shù)組

數(shù)組：多個數(shù)據(jù)元素按一定順序排列的集合
數(shù)組用[]表示，元素之間用","分隔

var array=[1, 1.5,"Hello", null, true]; //數(shù)組可以包括任意數(shù)據(jù)類型。

訪問數(shù)組

通過下標索引來獲取和設置數(shù)組某個特定的元素。
訪問數(shù)組的元素可以通過索引來訪問，索引的起始值為0：

console.log(array[0]) ;
console.log(array[1]) ;

函數(shù)

函數(shù)定義方法:
函數(shù)由關鍵字"function"，和函數(shù)名"functionname",和括號以及花括號組成:

function functionname (參數(shù)1,參數(shù)2) {
    //這里寫函數(shù)執(zhí)行的代碼
}

function：關鍵字 function 來聲明函數(shù)。
functionname ：函數(shù)名稱
(參數(shù)1,參數(shù)2)：（可選）括號內(nèi)列出函數(shù)的參數(shù)，多個參數(shù)以","分隔
{...}:花括號之間的代碼是函數(shù)體，由若干語句組成。

函數(shù)的實例和調(diào)用：

function add(x,y){
  var sum=x+y;
  return sum;
}

// var result=add(2,3);
// alert(result);
alert(add(2,3));

注意：JavaScript 對大小寫敏感。關鍵詞 function 必須是小寫的，并且必須以與函數(shù)名稱相同的大小寫來調(diào)用函數(shù)

函數(shù)體語句執(zhí)行到return時，函數(shù)就執(zhí)行完畢，并將結(jié)果返回。
如果沒有return語句，函數(shù)執(zhí)行完畢后也會返回結(jié)果，只是結(jié)果為undefined。

JavaScript 是弱類型的語言，擁有動態(tài)類型，同一個變量可以賦予不同類型的值。變量的類型在賦值時才能確定

  var b;
  b=20;
  b = "張三";
  b={};
  b=[];
  b=function(){ };
  console.log(typeof b);  

算術運算符

+  加法  x=2+3   5
-  減法  x=5-3   2

/ 除法 x=5/2 2.5
% 求余 x=5 %2 1
++ 自增 var x=3; x++; console.log(x)
-- 自減 var x=3; x--; console.log(x)

前自加：
var x=5;
var num1=++x; // 相當于x=x+1; var num1=x;
console.log("num1="+num1+" x="+x); //num1=6 x=6

后自加:
var x=5;
var num2=x++; // 相當于 var num2=x; x=x+1;
console.log("num2="+num2+" x="+x); //num2=5 x=6

前自減：
var x=5;
var num3=--x; //相當于 x=x-1; var num3=x;
console.log("num3="+num3+" x="+x); //num3=4 x=4

后自減
var x=5;
var num4=x--; //相當于 var num4=x; x=x-1;
console.log("num4="+num4+" x="+x); //num4=5 x=4

- 字符串"+" 遇到字符串，用來連接字符串

// 兩個都是字符串, 直接連接兩個字符串
var result1="hello"+"world";
console.log(result1); //helloworld
console.log(typeof result1);

//如果其中有一個是字符串, 另一個是其他類型, 則會先將其他的類型強制轉(zhuǎn)換成字符,然后再連接
var result2="hello"+2;
console.log(result2); //hello2
console.log(typeof result2);

####二進制, 八進制, 十進制, 十六進制(擴展)
進制:
在計算機處理器內(nèi)部只認識二進制, 在內(nèi)存存儲的數(shù)據(jù)其實就是大量的開關,  每個開關，可以存儲一個1或0，稱為一位(1bit)，每八位稱為1字節(jié)(1byte)

1byte = 8位 1KB = 1024byte 1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
..1PB, 1EB
1位 : 是二進制的0或者1

例如: 十進制的23在內(nèi)存中存儲的是二進制10111  23 --> 10111
00000000 00000000 00000000 00010111(內(nèi)存中存儲的23)

**進制:**

二進制: 0, 1 (0~1)
八進制: 0, 1, 2, 3, 4, 5, 6, 7 (0~7)
十進制: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 (0~9)
十六進制: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F (0~15)

>常用值: 2的次方  2^2 = 4
2^3 = 8
2^4 = 16
2^5 = 32
2^6 = 64
2^7 = 128
2^8 = 256
2^9 = 512
2^10 = 1024
2^11 = 2048

**進制轉(zhuǎn)換:**
2進制 :101011
轉(zhuǎn)10進制: (從右往左)1*2^0 + 1*2^1 + 0*2^2 + 1*2^3 +0*2^4 + 1*2^5 =  1+2+0+8+0+32 = 43
轉(zhuǎn)8進制: (從右往左3個一組 101 011): 1*2^0+0+1*2^2  1*2^0+1*2^1+0  = 53
轉(zhuǎn)16進制: (從右往左4個一組 0010 1011): 1*2^1  1*2^0+1*2^1+0+1*2^3 = 2B 

10進制: 43
轉(zhuǎn)2進制: 32+8+2+1 = 101011
轉(zhuǎn)8進制: 40+3 = 53
轉(zhuǎn)16進制: 32+11 = 2B

**其他的方法：**
!["轉(zhuǎn)2進制"](img/j1.jpg "轉(zhuǎn)2進制")
!["轉(zhuǎn)8進制"](img/j3.jpg "轉(zhuǎn)8進制")
!["轉(zhuǎn)16進制"](img/j2.jpg "轉(zhuǎn)16進制")

8進制: 53
轉(zhuǎn)10進制: 3*8^0+5*8^1 = 43

16進制: 2B
轉(zhuǎn)10進制:  11*16^0+2*16^1  = 32+11 = 43

8進制和16進制轉(zhuǎn)非10進制,可以先轉(zhuǎn)換成10進制,再由10進制轉(zhuǎn)
8進制的53轉(zhuǎn)16進制：
8進制轉(zhuǎn)10進制: 3*8^0+5*8^1 = 43
43轉(zhuǎn)16進制: 32+11 = 2B