目錄
JavaScript
JavaScript 是腳本語言
JavaScript 是一種輕量級的編程語言。
JavaScript 是可插入 HTML 頁面的編程代碼。
JavaScript的引入方式
1.script標簽內寫代碼
<script>
// 在這里寫你的JS代碼
</script>
2.引入額外的JS文件
<script src="myscript.js"></script>
JavaScript語言規范
注釋（注釋是代碼之母）
// 這是單行注釋
/*
這是
多行注釋
*/
結束符
JavaScript中的語句要以分號（;）為結束符。
JavaScript語言基礎
變量聲明
JavaScript的變量名可以使用_，數字，字母，$組成，不能以數字開頭。
聲明變量使用 var 變量名; 的格式來進行聲明
var name = "Alex";
var age = 18;
注意：
變量名是區分大小寫的。
推薦使用駝峰式命名規則。
保留字不能用做變量名。
補充：
ES6新增了let命令，用於聲明變量。其用法類似於var，但是所聲明的變量只在let命令所在的代碼塊內有效。例如：for循環的計數器就很適合使用let命令。
for (let i=0;i<arr.length;i++){...}
ES6新增const用來聲明常量。一旦聲明，其值就不能改變。
const PI = 3.1415;
PI // 3.1415
PI = 3
// TypeError: "PI" is read-only
保留字
abstract
boolean
byte
char
class
const
debugger
double
enum
export
extends
final
float
goto
implements
import
int
interface
long
native
package
private
protected
public
short
static
super
synchronized
throws
transient
volatile
注意:
var name = 'Alex';
undefined
var Name='Alex';
undefined
var name='yaya';
undefined
var 2name=12;
VM129:1 Uncaught SyntaxError: Invalid or unexpected token
var $name=12;
undefined
name
"yaya"
Name;
"Alex"
$name;
12
// woshi
undefined
let name=ww;
VM210:1 Uncaught ReferenceError: ww is not defined
at <anonymous>:1:10
(anonymous) @ VM210:1
let name='ww';
VM227:1 Uncaught SyntaxError: Identifier 'name' has already been declared
at <anonymous>:1:1
(anonymous) @ VM227:1
let age=18;
undefined
let nAme ='yaya';
undefined
const PI=3.1415; #constant不變的
undefined
PI=3
VM355:1 Uncaught TypeError: Assignment to constant variable.
at <anonymous>:1:3
(anonymous) @ VM355:1
let nAme='123';
VM373:1 Uncaught SyntaxError: Identifier 'nAme' has already been declared
at <anonymous>:1:1
var聲明過的變量可以再次聲明,let聲明過的變量不可以再次聲明
JavaScript數據類型
數值(Number)
JavaScript不區分整型和浮點型，就只有一種數字類型。
var a = 12.34;
var b = 20;
var c = 123e5; // 12300000 #e5表示123后有5個0
var d = 123e-5; // 0.00123 #e-5表示包括小數點后要有五位數,取走你前面定義的值,不夠就用0來填充,填充到5位,然后小數點前加個0
還有一種NaN，表示不是一個數字（Not a Number）。
常用方法：
parseInt("123") // 返回123 #parseInt函數 Int整型
parseInt("ABC") // 返回NaN,NaN屬性是代表非數字值的特殊值。該屬性用於指示某個值不是數字。
parseFloat("123.456") // 返回123.456 #Float浮點型
字符串(String)
var a = "Hello"
var b = "world;
var c = a + b;
console.log(c); // 得到Helloworld
常用方法：
| 方法 | 說明 |
|---|---|
| .length | 返回長度 |
| .trim() | 移除空白 |
| .trimLeft() | 移除左邊的空白 |
| .trimRight() | 移除右邊的空白 |
| .charAt(n) | 返回第n個字符 |
| .concat(value, ...) | 拼接 |
| .indexOf(substring, start) | 子序列位置 |
| .substring(from, to) | 根據索引獲取子序列 |
| .slice(start, end) | 切片 |
| .toLowerCase() | 小寫 |
| .toUpperCase() | 大寫 |
| .split(delimiter, limit) | 分割 |
trim 修剪 #相當於python中字符串的strip()
concat 接拼 #相當於字符串中的join,不過不同的是python中join只接拼可迭代對象,而且里面的元素只能是字符串,而js中會自動將數字類型轉為字符串類型,
charAt(n) #根據索引來取值
indexOf(substring,start) #根據值來取索引 start表示從哪個索引開始取值
'''
var name='yayaegon';
undefined
name.indexOf('a',1);
1
從索引1開始也包括1
'''
var name='yayaegon';
undefined
substring(from,to) #索引號取值,顧頭🙅不顧尾
name.substring(0,-1); #不能夠識別負數
"" #結果為空
slice(start,end) #索引號取值顧頭🙅不顧尾
name.slice(0,-1); #能夠識別負數
"yayaego"
name='yayaegon';
"yayaegon"
name;
"yayaegon"
name.toLowerCase();
"yayaegon"
name.toUpperCase();
"YAYAEGON"
name.split('e');
(2) ["yaya", "gon"]0: "yaya"1: "gon"length: 2__proto__: Array(0)
name.split('y');
(3) ["", "a", "aegon"]0: ""1: "a"2: "aegon"length: 3__proto__: Array(0)
name.split('y',0);
[]
name.split('y',1);
[""]
name.split('y',3);
(3) ["", "a", "aegon"]
.split(delimiter, limit) #可以通過第二個參數控制想要獲取切片之后的數據個數,某人從左到右取
string.slice(start, stop)和string.substring(start, stop)：
兩者的相同點：
如果start等於end，返回空字符串
name.slice(2,2);
"" #空
name.slice(9); #切的個數
""
name.substring(2,2);
""
如果stop參數省略，則取到字符串末
name.slice(1);
"ayaegon"
name.substring(2);
"yaegon"
如果某個參數超過string的長度，這個參數會被替換為string的長度
name.slice(0,9);
"yayaegon"
substirng()的特點：
如果 start > stop ，start和stop將被交換
如果參數是負數或者不是數字，將會被0替換
silce()的特點：
如果 start > stop 不會交換兩者
如果start小於0，則切割從字符串末尾往前數的第abs(start)個的字符開始(包括該位置的字符)
name='yayaegon';
"yayaegon"
name.slice(-1,7);#(7,7)start等於end，返回空字符串
""
name.slice(-1,8); #(7,8)顧頭不顧尾
"n"
name.slice(-3,2);#(5,2)不存在
""
name.slice(-3,5);#(5,5)start等於end，返回空字符串
""
name.slice(-5,5); #(3,5)顧頭不顧尾
"ae"
如果stop小於0，則切割在從字符串末尾往前數的第abs(stop)個字符結束(不包含該位置字符)
name.slice(-7,-1);
"ayaego"
'''
name.split(1);
["yayaegon"]
name.split(9);
["yayaegon"]
默認返回整個
'''
name.substring('88'); #轉成88,第88位不存在
""
name.substring(0,'33'); #'33'轉換成整型,某個參數超過string的長度，這個參數會被替換為string的長度
"yayaegon"
name.substring(0,0);#start等於end，返回空字符串
""
name.substring(0,-9); #-9變成0
""
name.substring(0);#stop參數省略，則取到字符串末
"yayaegon"
name.substring(10,1); #10>1,位置調換
"ayaegon"
name.substring(-10,1);#-10變成0
"y"
name.substring(1,-10); #1>-10,位置調換,然后-10又變成0 (0,1)
"y"
name.substring(0,0); #如果start等於end，返回空字符串
""
name.substring(0,33); #某個參數超過string的長度，這個參數會被替換為string的長度
"yayaegon"
name.substring(0,'3.3'); #自動轉為浮點型,然后再取整
"yay"
name.substring(0,'3.3.3'); #識別不了
""
ES6中引入了模板字符串。模板字符串（template string）是增強版的字符串，用反引號（`）標識。它可以當做普通字符串使用，也可以用來定義多行字符串，或者在字符串中嵌入變量。
普通字符串
`這是普通字符串！`
多行文本
`這是多行的
文本`
字符串中嵌入變量
var name = "jason", time = "today";
`Hello ${name}, how are you ${time}?` #相當於python中的%s
'''
注意：(相當於python的r)
如果模板字符串中需要使用反引號，則在其前面要用反斜杠轉義。
JSHint啟用ES6語法支持:/* jshint esversion: 6 */
`這是\`多行\`的
文本`
'''
布爾值(Booleam)
區別於Python，true和false都是小寫。
var a = true;
var b = false;
""(空字符串)、0、null、undefined、NaN都是false。
null和undefined
- null表示值是空，一般在需要指定或清空一個變量時才會使用，如 name=null;
- undefined表示當聲明一個變量但未初始化時，該變量的默認值是undefined。還有就是函數無明確的返回值時，返回的也是undefined。
null表示變量的值是空(null可以手動清空一個變量的值，使得該變量變為object類型，值為null)，undefined則表示只聲明了變量，但還沒有賦值。
var bilibili;
undefined
bilibili
undefined
name
"123"
var name='yaya';
undefined
name
"yaya"
var name='yaya';
undefined
var name='yaya';
undefined
var name='yaya';
undefined
name
"yaya"
let Name='yaya';
undefined
Name=null;
null
Name;
null
Name='yayaq';
"yayaq"
Name=null;
null
name=null;
null
name;
"null"
Name='yayaq';
"yayaq"
Name='yayaq';
"yayaq"
name
"null"
name.slice(0);
"null"
typeof(name);
"string"
Name=null;
null
typeof(Name);
"object"
對象(object)
JavaScript 中的所有事物都是對象：字符串、數值、數組、函數...此外，JavaScript 允許自定義對象。
JavaScript 提供多個內建對象，比如 String、Date、Array 等等。
對象只是帶有屬性和方法的特殊數據類型。
數組
數組對象的作用是：使用單獨的變量名來存儲一系列的值。類似於Python中的列表。
var a = [123, "ABC"];
console.log(a[1]); // 輸出"ABC"
常用方法：
| 方法 | 說明 |
|---|---|
| .length | 數組的大小 |
| .push(ele) | 尾部追加元素 |
| .pop() | 獲取尾部的元素 |
| .unshift(ele) | 頭部插入元素 |
| .shift() | 頭部移除元素 |
| .slice(start, end) | 切片 |
| .reverse() | 反轉 |
| .join(seq) | 將數組元素連接成字符串 |
| .concat(val, ...) | 連接數組 |
| .sort() | 排序 |
| .forEach() | 將數組的每個元素傳遞給回調函數 |
| .splice() | 刪除元素，並向數組添加新元素。 |
| .map() | 返回一個數組元素調用函數處理后的值的新數組 |
var l=[1,2,3,4,5,6]
undefined
l[1];
2
l.push(77);#尾部插入的是元素,相當於append,得到是元素的個數
7
l
(7) [1, 2, 3, 4, 5, 6, 77]0: 11: 22: 33: 44: 55: 66: 77length: 7__proto__: Array(0)
l.pop(); #刪除直接寫括號直接刪除尾部的第一個數,得到的是被刪的元素
77
l
(6) [1, 2, 3, 4, 5, 6]0: 61: 52: 43: 34: 25: 1length: 6__proto__: Array(0)
l.unshift(0);#加在頭部,相當於insert,得到是元素的個數
7
l
(7) [0, 1, 2, 3, 4, 5, 6]
l.shift();#刪除直接寫括號直接刪除頭部的第一個數,得到的是被刪的元素
0
l
(6) [1, 2, 3, 4, 5, 6]
l.slice(0,4);#切片
(4) [1, 2, 3, 4]
l.reverse(); #反轉
(6) [6, 5, 4, 3, 2, 1]
l.join('|'); #python的是'|'.join(l)
"6|5|4|3|2|1"
# val,index,sttrs為變量,可自定義
forEach()將數組的每個元素傳遞給回調函數
l.forEach(function(val){console.log(val)});
6
5
4
3
2
1
l.forEach(function(val,index,attrs){
console.log(val) #第一個參數是數組里面的元素
console.log(index)#第二個參數元素對應的索引值
console.log(attrs)});#第三個參數相當於元素所在的容器
6
0
[6, 5, 4, 3, 2, 1]
5
1
(6) [6, 5, 4, 3, 2, 1]
4
2
[6, 5, 4, 3, 2, 1]
3
3
[6, 5, 4, 3, 2, 1]
2
4
[6, 5, 4, 3, 2, 1]
1
5
[6, 5, 4, 3, 2, 1]
.splice()刪除元素，並向數組添加新元素。
var l=[1,2,3,4,5,6,7,8,9];
undefined
l.splice(1,3); #第一個參數是索引 第二個參數是個數
[2, 3, 4]
l.splice(1,3,'haha'); #先刪除后添加
[5, 6, 7]
l
[1, "haha", 8, 9]
var l=[1,2,3,4,5,6,7,8,9];
undefined
l.splice('1',3,'haha');#自動識別為數字
(3) [2, 3, 4]
l
(7) [1, "haha", 5, 6, 7, 8, 9]
splice()
語法：
splice(index,howmany,item1,.....,itemX)
參數：
| 參數 | 描述 |
|---|---|
| index | 必需。規定從何處添加/刪除元素。 該參數是開始插入和（或）刪除的數組元素的下標，必須是數字。 |
| howmany | 必需。規定應該刪除多少元素。必須是數字，但可以是 "0"。 如果未規定此參數，則刪除從 index 開始到原數組結尾的所有元素。 |
| item1, ..., itemX | 可選。要添加到數組的新元素 |
map()
語法：
map(function(currentValue,index,arr), thisValue)
參數：
| 參數 | 描述 |
|---|---|
| function(currentValue, index,arr) | 必須。函數，數組中的每個元素都會執行這個函數 函數參數: 參數描述currentValue必須。當前元素的值index可選。當期元素的索引值arr可選。當期元素屬於的數組對象 |
| thisValue | 可選。對象作為該執行回調時使用，傳遞給函數，用作 "this" 的值。 如果省略了 thisValue ，"this" 的值為 "undefined" |
var arr=[11,22,33,44]
undefined
arr.map(function(value,index,arr1){return value+1;})
(4) [12, 23, 34, 45]
arr
(4) [11, 22, 33, 44]
arr.map(function(value){return value+1;})
(4) [12, 23, 34, 45]
arr.map(function(value,1,arr1){return value+1;})
VM3283:1 Uncaught SyntaxError: Unexpected number
arr.map(function(value,22,arr1){return value+1;})
VM3292:1 Uncaught SyntaxError: Unexpected number
關於sort()需要注意：
如果調用該方法時沒有使用參數，將按字母順序對數組中的元素進行排序，說得更精確點，是按照字符編碼的順序進行排序。要實現這一點，首先應把數組的元素都轉換成字符串（如有必要），以便進行比較。
如果想按照其他標准進行排序，就需要提供比較函數，該函數要比較兩個值，然后返回一個用於說明這兩個值的相對順序的數字。比較函數應該具有兩個參數 a 和 b，其返回值如下：
若 a 小於 b，在排序后的數組中 a 應該出現在 b 之前，則返回一個小於 0 的值。
若 a 等於 b，則返回 0。
若 a 大於 b，則返回一個大於 0 的值。
function sortNumber(a,b){
return a - b
}
var arr1 = [11, 100, 22, 55, 33, 44]
arr1.sort(sortNumber)
#只能傳入數組,然后取出數組的兩個數傳給函數進行比較,然后得到返回值是否大於0或小於0,根據大小來進行這兩個升序或降序排序,每個元素都會跟每個元素進行比較.按照字符編碼的順序進行排序,然后傳入函數的時候有邏輯運算符,所以會按照數字大小來排序,不然的話,按照字符編碼排序就不會是我們想要的結果.
類型的查詢
typeof "abc" // "string"
typeof null // "object"
typeof true // "boolean"
typeof 123 // "number"
typeof是一個一元運算符（就像++，--，！，- 等一元運算符），不是一個函數，也不是一個語句。
對變量或值調用 typeof 運算符將返回下列值之一：
- undefined - 如果變量是 Undefined 類型的
- boolean - 如果變量是 Boolean 類型的
- number - 如果變量是 Number 類型的
- string - 如果變量是 String 類型的
- object - 如果變量是一種引用類型或 Null 類型的
運算符
算數運算符
+ - * / % ++ --
var x=10;
undefined
var res=++x;
undefined
res;
11
var res1 =x++;
undefined
res1;
11
var res2=++x;
undefined
res2;
13
這里由於的x++和++x在出現賦值運算式，x++會先賦值再進行自增1運算，而++x會先進行自增運算再賦值！
x++和++x的實際上是x=x+1 ,只是x++先給x賦值,如x=1,那x++等到了x=1,然后再取x++的時候就是2了,第二步就是賦值了,第3步++x的話就是3了
比較運算符
> >= < <= != == === !==
注意：
1 == “1” // true 弱等於
1 === "1" // false 強等於
//上面這張情況出現的原因在於JS是一門弱類型語言(會自動轉換數據類型)，所以當你用兩個等號進行比較時，JS內部會自動先將
//數值類型的1轉換成字符串類型的1再進行比較，所以我們以后寫JS涉及到比較時盡量用三等號來強制限制類型，防止判斷錯誤
邏輯運算符
true && false; #對應python的and
false
true || false; #對應python的or
true
!false; #對應python的not
true
賦值運算符
> >= < <= != == === !==
流程控制
'''
if-else
'''
var a = 10;
if (a > 5){
console.log("yes");
}else {
console.log("no");
}
'''
if-else if-else
語法格式:
if(條件){代碼塊}
else if(條件){代碼塊}
else{代碼塊}
'''
var a = 10;
if (a > 5){
console.log("a > 5");
}else if (a < 5) {
console.log("a < 5");
}else {
console.log("a = 5");
}
switch
'''
var day = new Date().getDay();
undefined
day;
6
day=new Date();
Sat Jun 01 2019 13:29:39 GMT+0800 (中國標准時間)
day.getDay();
'''
var day = new Date().getDay();
switch (day) {
case 0:
console.log("Sunday");
break;
case 1:
console.log("Monday");
break;
default:
console.log("...")
}
switch中的case子句通常都會加break語句，否則程序會繼續執行后續case中的語句。
for
for (var i=0;i<10;i++) {
console.log(i);
}
while
var i = 0;
while (i < 10) {
console.log(i);
i++;
}
三元運算
var a = 1;
var b = 2;
var c = a > b ? a : b
//這里的三元運算順序是先寫判斷條件a>b再寫條件成立返回的值為a,條件不成立返回的值為b;三元運算可以嵌套使用；
var a=10,b=20;
var x=a>b ?a:(b=="20")?a:b;
x
10
補充:
var attr =[1,2,3,4,5,6,7];
undefined
for (let i=0;i<attr.length;i++){console.log(attr[i])};
1
2
3
4
5
6
7
var i=1;
undefined
i=i++;
1
i=i++; #i=i=i+1 給了i本身賦值,為1,所以永遠都是1,不會再相加,而i=i+1是先賦值再相加
1
i++;
1
i=i++;
2
var i=1;
undefined
i++;
1
i++;
2
i
3
var x=1;
undefined
y=x++;
1
z=x++;
2
y=x++;
3
y=x++;
4
函數
JavaScript中的函數和Python中的非常類似，只是定義方式有點區別。
// 普通函數定義
function f1() {
console.log("Hello world!");
}
// 帶參數的函數
function f2(a, b) {
console.log(arguments); // 內置的arguments對象
console.log(arguments.length);
console.log(a, b);
}
// 帶返回值的函數
function sum(a, b){
return a + b;
}
sum(1, 2); // 調用函數
// 匿名函數方式
var sum = function(a, b){
return a + b;
}
sum(1, 2);
// 立即執行函數 書寫立即執行的函數，首先先寫兩個括號()()這樣防止書寫混亂
(function(a, b){
return a + b;
})(1, 2);
補充：
ES6中允許使用“箭頭”（=>）定義函數。
var f = v => v;
// 等同於
var f = function(v){
return v;
}
如果箭頭函數不需要參數或需要多個參數，就是用圓括號代表參數部分：
var f = () => 5;
// 等同於
var f = function(){return 5};
var sum = (num1, num2) => num1 + num2;
// 等同於
var sum = function(num1, num2){
return num1 + num2; //這里的return只能返回一個值，如果想返回多個值需要自己手動給他們包一個數組或對象中
}
數中的arguments參數
function add(a,b){
console.log(a+b);
console.log(arguments.length);
console.log(arguments[0]);//arguments相當於將出傳入的參數全部包含，這里取得就是第一個元素1
}
add(1,2)
輸出：
3
2
1
注意：
函數只能返回一個值，如果要返回多個值，只能將其放在數組或對象中返回。
unction func(){console.log('hello')} #無參函數
undefined
func();
hello
undefined
function bar(x,y){console.log(x,y)} #有參函數
undefined
bar(1,2);
1 2
undefined
bar(1,2,3,4,5,6); #參數可以多傳,但是打印的只是兩個
1 2
undefined
function f1(){return 'aaa'} #返回的關鍵字也是return
undefined
var res=f1();
undefined
res
"aaa"
fuction f2(){console.log(1)}
VM5438:1 Uncaught SyntaxError: Unexpected identifier
function f2(){console.log(1)}
undefined
var res1=f2();
1
undefined #不寫return默認返回undefined
function f3(){return 1,2,3,4,5}
undefined
var res2=f3();
undefined
res2
5 #如果return有多個參數默認返回最后一個
function f4(){return [1,2,3]}
undefined
var res4=f4();
undefined
res4
(3) [1, 2, 3] #如果你想返回多個參數可以將多個參數用容器裝起來
var lam=function(){console.log('name')} #匿名函數
undefined
lam();
name
undefined
(function(){console.log('name')})()#立即執行函數
VM5772:1 name
undefined
var f=() =>5;
等同於
var f=function(){return 5};
var sum=(num1, num2)=>num1+num2;
等同於
var sum=function(num1,num2){return num1+num2;} #這里的return只能返回一個值,如果想返回多個值需要自己手動給他們包一個數組或對象
函數的全局變量和局部變量
局部變量：
在JavaScript函數內部聲明的變量（使用 var）是局部變量，所以只能在函數內部訪問它（該變量的作用域是函數內部）。只要函數運行完畢，本地變量就會被刪除。
全局變量：
在函數外聲明的變量是全局變量，網頁上的所有腳本和函數都能訪問它。
變量生存周期：
JavaScript變量的生命期從它們被聲明的時間開始。
局部變量會在函數運行以后被刪除。
全局變量會在頁面關閉后被刪除。
作用域
首先在函數內部查找變量，找不到則到外層函數查找，逐步找到最外層。與python作用域關系查找一模一樣！
幾個例子：
var city = "BeiJing";
function f() {
var city = "ShangHai";
function inner(){
var city = "ShenZhen";
console.log(city);
}
inner();
}
f(); //輸出結果是？
var city = "BeiJing";
function Bar() {
console.log(city);
}
function f() {
var city = "ShangHai";
return Bar;
}
var ret = f();
ret(); // 打印結果是？
3.閉包
var city = "BeiJing";
function f(){
var city = "ShangHai";
function inner(){
console.log(city);
}
return inner;
}
var ret = f();
ret();
內置對象和方法
JavaScript中的所有事物都是對象：字符串、數字、數組、日期，等等。在JavaScript中，對象是擁有屬性和方法的數據。
我們在學習基本數據類型的時候已經帶大家了解了，JavaScript中的Number對象、String對象、Array對象等。
注意var s1 = "abc"和var s2 = new String("abc")的區別：typeof s1 --> string而 typeof s2 --> Object
自定義對象
JavaScript的對象（Object）本質上是鍵值對的集合（Hash結構），但是只能用字符串作為鍵。
var a = {"name": "Alex", "age": 18};
console.log(a.name);
console.log(a["age"]);
遍歷對象中的內容：
var a = {"name": "Alex", "age": 18};
for (var i in a){
console.log(i, a[i]);
}
創建對象：
var person=new Object(); // 創建一個person對象
person.name="Alex"; // person對象的name屬性
person.age=18; // person對象的age屬性
注意：
ES6中提供了Map數據結構。它類似於對象，也是鍵值對的集合，但是“鍵”的范圍不限於字符串，各種類型的值（包括對象）都可以當做鍵。
也就是說，Object結構提供了“字符串--值”的對應，Map結構提供了“值--值”的對應，是一種更完善的Hash結構實現。
Date對象
創建Date對象
//方法1：不指定參數
var d1 = new Date();
console.log(d1.toLocaleString());
//方法2：參數為日期字符串
var d2 = new Date("2004/3/20 11:12");
console.log(d2.toLocaleString());
var d3 = new Date("04/03/20 11:12");
console.log(d3.toLocaleString());
//方法3：參數為毫秒數
var d3 = new Date(5000);
console.log(d3.toLocaleString());
console.log(d3.toUTCString());
//方法4：參數為年月日小時分鍾秒毫秒
var d4 = new Date(2004,2,20,11,12,0,300);
console.log(d4.toLocaleString()); //毫秒並不直接顯示
Date對象的方法：
var d = new Date();
//getDate() 獲取日
//getDay () 獲取星期
//getMonth () 獲取月（0-11）
//getFullYear () 獲取完整年份
//getYear () 獲取年
//getHours () 獲取小時
//getMinutes () 獲取分鍾
//getSeconds () 獲取秒
//getMilliseconds () 獲取毫秒
//getTime () 返回累計毫秒數(從1970/1/1午夜)
練習：
編寫代碼，將當前日期按“2017-12-27 11:11 星期三”格式輸出。
const WEEKMAP = {
0:"星期天",
1:"星期一",
2:"星期二",
3:"星期三",
4:"星期四",
5:"星期五",
6:"星期六"
}; //定義一個數字與星期的對應關系對象
function showTime() {
var d1 = new Date();
var year = d1.getFullYear();
var month = d1.getMonth() + 1; //注意月份是從0~11
var day = d1.getDate();
var hour = d1.getHours();
var minute = d1.getMinutes() < 10?"0"+d1.getMinutes():d1.getMinutes(); //三元運算
var week = WEEKMAP[d1.getDay()]; //星期是從0~6
var strTime = `
${year}-${month}-${day} ${hour}:${minute} ${week}
`;
console.log(strTime)
};
showTime();
JSON對象
var str1 = '{"name": "Alex", "age": 18}';
var obj1 = {"name": "Alex", "age": 18};
// JSON字符串轉換成對象
var obj = JSON.parse(str1);
// 對象轉換成JSON字符串
var str = JSON.stringify(obj1);
RegExp對象
// 定義正則表達式兩種方式
var reg1 = new RegExp("^[a-zA-Z][a-zA-Z0-9]{5,11}");
var reg2 = /^[a-zA-Z][a-zA-Z0-9]{5,9}$/;
// 正則校驗數據
reg1.test('jason666')
reg2.test('jason666')
/*第一個注意事項，正則表達式中不能有空格*/
// 全局匹配
var s1 = 'egondsb dsb dsb';
s1.match(/s/)
s1.match(/s/g)
var reg2 = /^[a-zA-Z][a-zA-Z0-9]{5,9}$/g
reg2.test('egondsb');
reg2.test('egondsb');
reg2.lastIndex;
/*第二個注意事項，全局匹配時有一個lastIndex屬性*/
// 校驗時不傳參數
var reg2 = /^[a-zA-Z][a-zA-Z0-9]{5,9}$/
reg2.test();
reg2.test(undefined);
var reg3 = /undefined/;
reg3.test();