【精選】JavaScript語法大合集【附代碼和超詳細(xì)介紹以及使用】

JavaScript語法大合集

JavaScript引入到文件

嵌入到HTML文件中

<body>
    <script>
        var num=10;
        console.log(num);
    </script>
</body>

引入本地獨(dú)立JS文件

<body>
    <script src="./hello.js"></script>
</body>

引入網(wǎng)絡(luò)來源文件

<body>
    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.6.0/jquery.min.js"> </script>
</body>

JavaScript注釋與常見輸出方式

JavaScript注釋

源碼中注釋是不被引擎所解釋的，它的作用是對代碼進(jìn)行解釋。Javascript 提供兩種注釋的寫法：一種是單行注釋，用//起頭；另一種是多行注釋，放在/和/之間。

// 這是單行注釋


/*
 這是
 多行
 注釋
*/

嵌入在HTML文件中的注釋

<!-- 注釋 -->

溫馨提示

注釋的快捷鍵：ctrl + /

JavaScript輸出方式

JavaScript有很多種輸出方式，都可以讓我們更直觀的看到程序運(yùn)行的結(jié)果

// 在瀏覽器中彈出一個對話框,然后把要輸出的內(nèi)容展示出來,alert都是把要輸出的內(nèi)容首先轉(zhuǎn)換為字符串然后在輸出的
        alert("這是要輸出到彈出框的內(nèi)容");

        //輸出到頁面
        document.write("這是要輸出到頁面的內(nèi)容");

        //輸出到控制臺
        console.log(20);

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

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

JavaScript 語言的每一個值，都屬于某一種數(shù)據(jù)類型。JavaScript 的數(shù)據(jù)類型，共有六種。（ES6 又新增了第七種 Symbol 類型的值和第八種 BigInt類型，當(dāng)前課程暫不涉及）

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

原始類型(基礎(chǔ)類型)

//數(shù)值類型
var age = 20;
//字符串類型
var name = "java";
//布爾類型
var learn = true;

合成類型(復(fù)合類型)

對象：因?yàn)橐粋€對象往往是多個原始類型的值的合成，可以看作是一個存放各種值的容器

//對象類型（object）
var user = {
  name:"java",
  age:20,
  learn:true
}

溫馨提示

至于undefined和null，一般將它們看成兩個特殊值。

typeof運(yùn)算符

JavaScript 有三種方法，可以確定一個值到底是什么類型。而我們現(xiàn)在需要接觸到的就是typeof

數(shù)值返回number

typeof 123 // "number"

字符串返回string

typeof '123' // "string"

布爾值返回boolean

typeof false // "boolean"

對象返回object

typeof {} // "object"

null和undefined的區(qū)別

null與undefined都可以表示“沒有”，含義非常相似。將一個變量賦值為undefined或null，老實(shí)說，語法效果幾乎沒區(qū)別。既然含義與用法都差不多，為什么要同時設(shè)置兩個這樣的值，這不是無端增加復(fù)雜度，令初學(xué)者困擾嗎？這與歷史原因有關(guān)

null一般表示對象為“沒有”
undefined一般表示數(shù)據(jù)為“沒有”

<script>

        var num=20;
        var name ="java";
        var hunfo=false;
        var student={};
        console.log(typeof num); //number
        console.log(typeof name); //string
        console.log(typeof hunfo); //boolean
        console.log(typeof student);//object

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

        
    </script>

運(yùn)算符之算術(shù)運(yùn)算符

加減乘除運(yùn)算符

加減乘除運(yùn)算符就是基本的數(shù)學(xué)運(yùn)算符效果

10 + 10; // 20
100 - 10; // 90
10 * 2; //20
10 / 5; 2

余數(shù)運(yùn)算符

余數(shù)運(yùn)算符是比較常用的，因?yàn)樵谶壿嬎季S上尋找規(guī)律，余數(shù)運(yùn)算符是很好用的

13 % 5 // 3

自增和自減運(yùn)算符

自增和自減運(yùn)算符，是一元運(yùn)算符，只需要一個運(yùn)算子。它們的作用是將運(yùn)算子首先轉(zhuǎn)為數(shù)值，然后加上1或者減去1

var x = 1;
var y = 1;
++x // 2
--y // 0

自增和自減運(yùn)算符有一個需要注意的地方，就是放在變量之后，會先返回變量操作前的值，再進(jìn)行自增/自減操作；放在變量之前，會先進(jìn)行自增/自減操作，再返回變量操作后的值。

var x = 1;
var y = 1;


x++ // 1
++y // 2


var x = 10;
var y = 20;
console.log(x++ + y);// 30

運(yùn)算符之賦值運(yùn)算符

賦值運(yùn)算符（Assignment Operators）用于給變量賦值

最常見的賦值運(yùn)算符，當(dāng)然就是等號（=）

// 將 1 賦值給變量 x
var x = 1;


// 將變量 y 的值賦值給變量 x
var x = y;

賦值運(yùn)算符還可以與其他運(yùn)算符結(jié)合，形成變體。下面是與算術(shù)運(yùn)算符的結(jié)合

// 等同于 x = x + y
x += y


// 等同于 x = x - y
x -= y


// 等同于 x = x * y
x *= y


// 等同于 x = x / y
x /= y


// 等同于 x = x % y
x %= y

運(yùn)算符之比較運(yùn)算符

比較運(yùn)算符用于比較兩個值的大小，然后返回一個布爾值，表示是否滿足指定的條件。

2 > 1 // true

JavaScript 一共提供了8個比較運(yùn)算符。

比較運(yùn)算符	描述
<	小于運(yùn)算符
>	大于運(yùn)算符
<=	小于或等于運(yùn)算符
>=	大于或等于運(yùn)算符
==	相等運(yùn)算符
===	嚴(yán)格相等運(yùn)算符
!=	不相等運(yùn)算符
!==	嚴(yán)格不相等運(yùn)算符

“= =”和“===”的區(qū)別

==：雙等比較值

===：三等比較值和類型

運(yùn)算符之布爾運(yùn)算符

取反運(yùn)算符（!）

布爾值取反

!true // false
!false // true

非布爾值取反

對于非布爾值，取反運(yùn)算符會將其轉(zhuǎn)為布爾值。可以這樣記憶，以下六個值取反后為true，其他值都為false。

溫馨提示

undefined null false 0 NaN 空字符串（‘’）

!undefined // true
!null // true
!0 // true
!NaN // true
!"" // true


!54 // false
!'hello' // false

且運(yùn)算符（&&）

多個條件都要滿足

如果一個人一直做好事，突然有一天做了一件壞事，那么人們會認(rèn)為這個人很虛偽，以前說不定都是裝的！對這個人不在認(rèn)可

console.log(10 < 20 && 10 >5); // true

或運(yùn)算符（||）

滿足一個條件即可

如果一個人一直做壞事，突然有一天做了一件好事，那么人們會認(rèn)為這個人其實(shí)還不錯，以前也許是另有原因！對這個人突然就認(rèn)可了

console.log(10 < 20 || 10 < 5); // true

條件語句之 if語句

if結(jié)構(gòu)先判斷一個表達(dá)式的布爾值，然后根據(jù)布爾值的真?zhèn)危瑘?zhí)行不同的語句。所謂布爾值，指的是 JavaScript 的兩個特殊值，true表示真，false表示偽。

if語句語法規(guī)范

if (布爾值){
  語句; 
}

需要注意的是，“布爾值”往往由一個條件表達(dá)式產(chǎn)生的，必須放在圓括號中

var m = 3;
if (m = = = 3) {
  m++;
}
console.log(m); // 4

注意，if后面的表達(dá)式之中，不要混淆賦值表達(dá)式（=）、嚴(yán)格相等運(yùn)算符（=）和相等運(yùn)算符（）。尤其是賦值表達(dá)式不具有比較作用。

var x = 1;
var y = 2;
if (x = y) {
  console.log(x);
}

條件語句之 if…else

if…else基本結(jié)構(gòu)

if代碼塊后面，還可以跟一個else代碼塊，表示不滿足條件時，所要執(zhí)行的代碼。

if (m === 3) {
 // 滿足條件時，執(zhí)行的語句
} else {
 // 不滿足條件時，執(zhí)行的語句
}

多個if…else連接

對同一個變量進(jìn)行多次判斷時，多個if…else語句可以連寫在一起。

if (m === 0) {
 // ...
} else if (m === 1) {
 // ...
} else if (m === 2) {
 // ...
} else {
 // ...
}

if…else嵌套

var eat = true;
var food = "豬肉燉粉條";
if (eat) {
  if (food == "雙椒魚頭") {
    console.log('雙椒魚頭');    
   }else{
    console.log("豬肉燉粉條");
   }
} else {
  console.log('不吃了');
}

else代碼塊總是與離自己最近的那個if語句配對。

條件語句之 switch

多個if…else連在一起使用的時候，可以轉(zhuǎn)為使用更方便的switch結(jié)構(gòu)

switch (fruit) {
 case "banana":
  // ...
  break;
 case "apple":
  // ...
  break;
 default:
  // ...
}

需要注意的是，每個case代碼塊內(nèi)部的break語句不能少，否則會接下去執(zhí)行下一個case代碼塊，而不是跳出switch結(jié)構(gòu)。

var x = 1;


switch (x) {
 case 1:
  console.log('x 等于1');
 case 2:
  console.log('x 等于2');
 default:
  console.log('x 等于其他值');
}
// x等于1
// x等于2
// x等于其他值

三元運(yùn)算符

JavaScript還有一個三元運(yùn)算符（即該運(yùn)算符需要三個運(yùn)算子）?:，也可以用于邏輯判斷。

(條件) ? 表達(dá)式1 : 表達(dá)式2

這個三元運(yùn)算符可以被視為if…else…的簡寫形式，因此可以用于多種場合。

判斷一個整數(shù)是奇數(shù)與偶數(shù)

if…else語句

var n = 100;
if (n % 2 = = = 0) {
 console.log("偶數(shù)");
} else {
 console.log("奇數(shù)");
}

三元運(yùn)算符

var n = 100;
n % 2 = = = 0 ? '偶數(shù)' : '奇數(shù)'

循環(huán)語句之for

循環(huán)語句用于重復(fù)執(zhí)行某個操作

for語句就是循環(huán)命令，可以指定循環(huán)的起點(diǎn)、終點(diǎn)和終止條件。它的格式如下

for (初始化表達(dá)式; 條件; 迭代因子) {
 語句
}

for語句后面的括號里面，有三個表達(dá)式。

初始化表達(dá)式（initialize）：確定循環(huán)變量的初始值，只在循環(huán)開始時執(zhí)行一次。
布爾表達(dá)式（test）：每輪循環(huán)開始時，都要執(zhí)行這個條件表達(dá)式，只有值為真，才繼續(xù)進(jìn)行循環(huán)。
迭代因子（increment）：每輪循環(huán)的最后一個操作，通常用來遞增循環(huán)變量。

var x = 3;
for (var i = 0; i < x; i++) {
 console.log(i);
}

for語句的三個表達(dá)式，可以省略任何一個，也可以全部省略。

for ( ; ; ){
 console.log('Hello World');
}

溫馨提示

如果三個都省略，結(jié)果就導(dǎo)致了一個無限循環(huán)（死循環(huán)）

for循環(huán)語句實(shí)操

循環(huán)輸出1~100之間數(shù)字的和

var sum=0;
for(var i=1;i<=100;i++){
  sum+=i;
}
console.log(sum);

循環(huán)輸出1000以內(nèi)的奇數(shù)

for(i = 0 ; i<1000; i ++){
  if( i % 2 ==1){
    console.log( i + " ");  
   }
}

打印九九乘法表

for(var i = 1;i <= 9;i++){
  document.write("<br>"); 
  for(var j = 1;j <= i;j++){
    sum = i * j;
    document.write(i ,"*",j ,"=",sum," ");
   }
}

循環(huán)語句之while

While語句包括一個循環(huán)條件和一段代碼塊，只要條件為真，就不斷循環(huán)執(zhí)行代碼塊。

while (條件) {
 語句;
}

while循環(huán)

var i = 0;
while (i < 100) {
 console.log('i 當(dāng)前為：' + i);
 i = i + 1;
}

下面的例子是一個無限循環(huán)，因?yàn)檠h(huán)條件總是為真

while (true) {
 console.log('Hello, world');
}

所有for循環(huán)，都可以改寫成while循環(huán)

// for
var x = 3;
for (var i = 0; i < x; i++) {
 console.log(i);
}


// while
var x = 3;
var i = 0;
while (i < x) {
 console.log(i);
 i++;
}

break 語句和 continue 語句

break語句和continue語句都具有跳轉(zhuǎn)作用，可以讓代碼不按既有的順序執(zhí)行

break

break語句用于跳出代碼塊或循環(huán)

for (var i = 0; i < 5; i++) {
  if (i === 3){
    break;
   }
  console.log(i);
}

continue

continue語句用于立即終止本輪循環(huán)，返回循環(huán)結(jié)構(gòu)的頭部，開始下一輪循環(huán)

for (var i = 0; i < 5; i++) {
  if (i === 3){
    continue;
    }
  console.log(i);
}

字符串

字符串就是零個或多個排在一起的字符，放在單引號或雙引號之中

'java'
"java"

單引號字符串的內(nèi)部，可以使用雙引號。雙引號字符串的內(nèi)部，可以使用單引號

'key = "value"'
"It's a long java"

如果要在單引號字符串的內(nèi)部，使用單引號，就必須在內(nèi)部的單引號前面加上反斜杠，用來轉(zhuǎn)義。雙引號字符串內(nèi)部使用雙引號，也是如此

'Did she say \'Hello\'?'
// "Did she say 'Hello'?"


"Did she say \"Hello\"?"
// "Did she say "Hello"?"

溫馨提示

字符串默認(rèn)只能寫在一行內(nèi)，分成多行將會報錯

如果長字符串必須分成多行，可以在每一行的尾部使用反斜杠

var longString = 'Long \
long \
string';
longString
// "Long long long string"

length 屬性

length屬性返回字符串的長度，該屬性也是無法改變的

var s = 'java';
s.length // 4

字符串方法_charAt()

charAt方法返回指定位置的字符，參數(shù)是從0開始編號的

var s = new String('java');


s.charAt(1) // "a"
s.charAt(s.length - 1) // "a"

如果參數(shù)為負(fù)數(shù)，或大于等于字符串的長度，charAt返回空字符串

'java'.charAt(-1) // ""
'java'.charAt(9) // ""

字符串方法_concat()

concat方法用于連接兩個字符串，返回一個新字符串，不改變原字符串

var s1 = 'zhongguo';
var s2 = 'java';


s1.concat(s2) // "zhongguojava"
s1 // "zhongguo"

該方法可以接受多個參數(shù)

'zhongguo'.concat('java', 'script') // "zhongguojavascript"

如果參數(shù)不是字符串，concat方法會將其先轉(zhuǎn)為字符串，然后再連接

var one = 1;
var two = 2;
var three = '3';


''.concat(one, two, three) // "123"

字符串方法_substring()

substring方法用于從原字符串取出子字符串并返回，不改變原字符串。它的第一個參數(shù)表示子字符串的開始位置，第二個位置表示結(jié)束位置（返回結(jié)果不含該位置）

'zhongguo'.substring(0, 2) // "zh"

如果省略第二個參數(shù)，則表示子字符串一直到原字符串的結(jié)束

'zhongguo'.substring(2) // "ongguo"

如果第一個參數(shù)大于第二個參數(shù)，substring方法會自動更換兩個參數(shù)的位置

'zhongguo'.substring(9, 2) // "ongguo"
// 等同于
'zhongguo'.substring(2, 9) // "ongguo"

如果參數(shù)是負(fù)數(shù)，substring方法會自動將負(fù)數(shù)轉(zhuǎn)為0

'zhongguo'.substring(-3) // "zhongguo"
'zhongguo'.substring(2, -3) // "zh"

字符串方法_substr()

substr方法用于從原字符串取出子字符串并返回，不改變原字符串，跟substring方法的作用相同

substr方法的第一個參數(shù)是子字符串的開始位置（從0開始計算），第二個參數(shù)是子字符串的長度

'zhongguo'.substr(2, 6); // ongguo

如果省略第二個參數(shù)，則表示子字符串一直到原字符串的結(jié)束

'zhongguo'.substr(2) // "ongguo"

如果第一個參數(shù)是負(fù)數(shù)，表示倒數(shù)計算的字符位置。如果第二個參數(shù)是負(fù)數(shù)，將被自動轉(zhuǎn)為0，因此會返回空字符串

'zhongguo'.substr(-6) // "ongguo"
'zhongguo'.substr(4, -1) // ""

字符串方法_indexOf()

indexOf方法用于確定一個字符串在另一個字符串中第一次出現(xiàn)的位置，返回結(jié)果是匹配開始的位置。如果返回-1，就表示不匹配

'hello world'.indexOf('o') // 4
'zhongguo'.indexOf('java') // -1

indexOf方法還可以接受第二個參數(shù)，表示從該位置開始向后匹配

'hello world'.indexOf('o', 6) // 7

字符串方法_trim()

trim方法用于去除字符串兩端的空格，返回一個新字符串，不改變原字符串

'  hello world  '.trim()
// "hello world"

該方法去除的不僅是空格，還包括制表符（\t、\v）、換行符（\n）和回車符（\r）

'\r\nzhongguo \t'.trim() // 'zhongguo '

ES6擴(kuò)展方法，trimEnd()和trimStart()方法

"  zhongguo  ".trimEnd(); //   zhongguo 
"  zhongguo  ".trimStart(); // zhongguo

數(shù)組

數(shù)組（array）是按次序排列的一組值。每個值的位置都有編號（從0開始），整個數(shù)組用方括號表示。

var arr = ['sxt', 'baizhan', 'it'];

兩端的方括號是數(shù)組的標(biāo)志。sxt是0號位置，baizhan是1號位置，it是2號位置。（位置也被稱為下標(biāo)）

除了在定義時賦值，數(shù)組也可以先定義后賦值。

var arr = [];


arr[0] = 'zhongguo';
arr[1] = 'java';
arr[2] = 'it';

任何類型的數(shù)據(jù)，都可以放入數(shù)組

var arr = [ 100, [1, 2, 3],false ];

如果數(shù)組的元素還是數(shù)組，就形成了多維數(shù)組

var a = [[1, 2], [3, 4]];
a[0][1] // 2
a[1][1] // 4

length 屬性

數(shù)組的length屬性，返回數(shù)組的成員數(shù)量

['zhongguo', 'java', 'it'].length // 3

數(shù)組的遍歷

數(shù)組的遍歷可以考慮使用for循環(huán)或while循環(huán)

var a = ['zhongguo', 'java', 'it'];


// for循環(huán)
for(var i = 0; i < a.length; i++) {
 console.log(a[i]);
}


// while循環(huán)
var i = 0;
while (i < a.length) {
 console.log(a[i]);
 i++;
}

for…in遍歷數(shù)組

var a = ['zhongguo', 'java', 'it'];


for (var i in a) {
 console.log(a[i]);
}

數(shù)組靜態(tài)方法_Array.isArray()

Array.isArray方法返回一個布爾值，表示參數(shù)是否為數(shù)組。它可以彌補(bǔ)typeof運(yùn)算符的不足

var arr = ["中國人", 100, true];
console.log(typeof arr); // object

var arr = ['zhongguo', 'java', 'it'];
Array.isArray(arr) // true

數(shù)組方法_join()

join方法以指定參數(shù)作為分隔符，將所有數(shù)組成員連接為一個字符串返回。如果不提供參數(shù)，默認(rèn)用逗號分隔

var a = [1, 2, 3, 4];


a.join(' ') // '1 2 3 4'4
a.join(' | ') // "1 | 2 | 3 | 4"
a.join() // "1,2,3,4"

如果數(shù)組成員是undefined或null或空位，會被轉(zhuǎn)成空字符串

[undefined, null].join('#')
// '#'


['a',, 'b'].join('-')
// 'a--b'

數(shù)組的join配合字符串的split可以實(shí)現(xiàn)數(shù)組與字符串的互換

var arr = ["a","b","c"];
var myArr = arr.join("");
console.log(myArr);
console.log(myArr.split(""));

數(shù)組方法_concat()

concat方法用于多個數(shù)組的合并。它將新數(shù)組的成員，添加到原數(shù)組成員的后部，然后返回一個新數(shù)組，原數(shù)組不變

['hello'].concat(['world'])
// ["hello", "world"]


['hello'].concat(['world'], ['!'])
// ["hello", "world", "!"]

除了數(shù)組作為參數(shù)，concat也接受其他類型的值作為參數(shù)，添加到目標(biāo)數(shù)組尾部。

[1, 2, 3].concat(4, 5, 6)
// [1, 2, 3, 4, 5, 6]

應(yīng)用場景

上拉加載，合并數(shù)據(jù)

數(shù)組方法_reverse()

reverse方法用于顛倒排列數(shù)組元素，返回改變后的數(shù)組。注意，該方法將改變原數(shù)組

var a = ['a', 'b', 'c'];


a.reverse() // ["c", "b", "a"]
a // ["c", "b", "a"]

實(shí)現(xiàn)一個字符串反轉(zhuǎn)排列

var str = "hello";
str.split("").reverse().join("")

函數(shù)

函數(shù)是一段可以反復(fù)調(diào)用的代碼塊

函數(shù)的聲明

function 命令： function命令聲明的代碼區(qū)塊，就是一個函數(shù)。function命令后面是函數(shù)名，函數(shù)名后面是一對圓括號，里面是傳入函數(shù)的參數(shù)。函數(shù)體放在大括號里面。

function print(s) {
 console.log(s);
}

函數(shù)名的提升

JavaScript 引擎將函數(shù)名視同變量名，所以采用function命令聲明函數(shù)時，整個函數(shù)會像變量聲明一樣，被提升到代碼頭部

add();


function add() {}

函數(shù)參數(shù)

函數(shù)運(yùn)行的時候，有時需要提供外部數(shù)據(jù)，不同的外部數(shù)據(jù)會得到不同的結(jié)果，這種外部數(shù)據(jù)就叫參數(shù)

function square(x) {
    console.log(x * x);
}


square(2) // 4
square(3) // 9

函數(shù)返回值

JavaScript函數(shù)提供兩個接口實(shí)現(xiàn)與外界的交互，其中參數(shù)作為入口，接收外界信息；返回值作為出口，把運(yùn)算結(jié)果反饋給外界

function getName(name){
  return name;
}


var myName = getName("zhongguo")
console.log(myName); // zhongguo

溫馨提示

return 后面不能在添加任何代碼，因?yàn)椴粫?zhí)行

對象概述

什么是對象？對象（object）是 JavaScript 語言的核心概念，也是最重要的數(shù)據(jù)類型

簡單說，對象就是一組“鍵值對”（key-value）的集合，是一種無序的復(fù)合數(shù)據(jù)集合

var user = {
 name: 'zhongguo',
 age: '13'
};

對象的每一個鍵名又稱為“屬性”（property），它的“鍵

值”可以是任何數(shù)據(jù)類型。如果一個屬性的值為函數(shù)，通常把這個屬性稱為“方法”，它可以像函數(shù)那樣調(diào)用

var user = {
 getName: function (name) {
  return name;
  }
};
user.getName("zhongguo") // zhongguo

如果屬性的值還是一個對象，就形成了鏈?zhǔn)揭?/p>

var user = {
  name:"zhongguo",
  age:13,
  container:{
    frontEnd:["Web前端","Android","iOS"],
    backEnd:["Java","Python"]
   }
}
user.container.frontEnd // ["Web前端","Android","iOS"]

Math對象

Math是 JavaScript 的原生對象，提供各種數(shù)學(xué)功能。

Math.abs()

Math.abs方法返回參數(shù)值的絕對值

Math.abs(1) // 1
Math.abs(-1) // 1

Math.max()，Math.min()

Math.max方法返回參數(shù)之中最大的那個值，Math.min返回最小的那個值。如果參數(shù)為空, Math.min返回Infinity, Math.max返回-Infinity。

Math.max(2, -1, 5) // 5
Math.min(2, -1, 5) // -1
Math.min() // Infinity
Math.max() // -Infinity

Math.floor()，Math.ceil()

Math.floor方法返回小于參數(shù)值的最大整數(shù)

Math.floor(3.2) // 3
Math.floor(-3.2) // -4

Math.ceil方法返回大于參數(shù)值的最小整數(shù)

Math.ceil(3.2) // 4
Math.ceil(-3.2) // -3

Math.random()

Math.random()返回0到1之間的一個偽隨機(jī)數(shù)，可能等于0，但是一定小于1

Math.random() // 0.28525367438365223

任意范圍的隨機(jī)數(shù)生成函數(shù)如下

function getRandomArbitrary(min, max) {
 return Math.random() * (max - min) + min;
}


getRandomArbitrary(5, 10)

Date對象

Date對象是 JavaScript 原生的時間庫。它以1970年1月1日00:00:00作為時間的零點(diǎn)，可以表示的時間范圍是前后各1億天（單位為毫秒）

Date.now()

Date.now方法返回當(dāng)前時間距離時間零點(diǎn)（1970年1月1日 00:00:00 UTC）的毫秒數(shù)，相當(dāng)于 Unix 時間戳乘以1000

Date.now();  // 1635216733395

時間戳

時間戳是指格林威治時間1970年01月01日00時00分00秒(北京時間1970年01月01日08時00分00秒)起至現(xiàn)在的總秒數(shù)。

格林威治和北京時間就是時區(qū)的不同

Unix是20世紀(jì)70年代初出現(xiàn)的一個操作系統(tǒng)，Unix認(rèn)為1970年1月1日0點(diǎn)是時間紀(jì)元。JavaScript也就遵循了這一約束

Date對象提供了一系列get*方法，用來獲取實(shí)例對象某個方面的值

實(shí)例方法get類

getTime()：返回實(shí)例距離1970年1月1日00:00:00的毫秒數(shù) getDate()：返回實(shí)例對象對應(yīng)每個月的幾號（從1開始） getDay()：返回星期幾，星期日為0，星期一為1，以此類推 getYear()：返回距離1900的年數(shù) getFullYear()：返回四位的年份 getMonth()：返回月份（0表示1月，11表示12月） getHours()：返回小時（0-23） getMilliseconds()：返回毫秒（0-999） getMinutes()：返回分鐘（0-59） getSeconds()：返回秒（0-59）

var d = new Date('January 6, 2022');
d.getDate() // 6
d.getMonth() // 0
d.getYear() // 122
d.getFullYear() // 2022

編寫函數(shù)獲得本年度剩余天數(shù)

function leftDays() {
 var today = new Date();
 var endYear = new Date(today.getFullYear(), 11, 31, 23, 59, 59, 999);
 var msPerDay = 24 * 60 * 60 * 1000;
 return Math.round((endYear.getTime() - today.getTime()) / msPerDay);
}

posted @ 2023-11-16 21:24 Gjq- 閱讀(103) 評論(0) 收藏舉報來源

刷新頁面返回頂部