尻逼美女一区久久国产,久久丰满成人熟妇国产

Js接口盤點

Array

array.push(item...)

作用：往數組添加元素，尾部添加

array.unshift(item...)

作用：往數組添加元素，頭部添加

array.concat(item...)

作用：把元素插入數組，和push不同的點在于，concat可以指定元素是數組，即把一個數組在尾部插入。

// 和刪除相對應，增加也有從頭部增加和尾部增加

// 插入單個元素
// 1. 從頭部插入 arr.unshift(item...)
let arr = [1,2,3];
arr.unshift(0);
console.log(arr);  //[0,1,2,3]

// 2. 從尾部插入 arr.push(item...)
arr = [1,2,3];
arr.push(4);
console.log(arr);  //[1,2,3,4]

// 3. 插入多個元素
// 顯然如果插入多個元素，我們一個個去push是很麻煩的，所以提供了一個方法
// arr.concat(item...) concat 這個單詞的含義是合并數組;
arr1 = [1,2];
arr2 = [3,4];
arr = arr1.concat(arr2);
console.log(arr);   //[1,2,3,4] & arr1 沒有改變 還是[1,2]

array.pop()

作用：刪除元素，從尾部刪除

array.shift()

作用：刪除元素，從頭部刪除

//arr.shift() 刪除第一個元素并返回
let arr = [1,2,3];
let element = arr.shift(); //element 是 1
console.log(element);

//arr.pop() 刪除最后一個元素并返回
arr = [1,2,3];
element = arr.pop(); //element 是 3
console.log(element);

array.reverse()

作用: 反轉數組的順序，并返回array本身

/**
 * 使用arr.reverse()反轉數組
 */
let arr = [1,2,3];
arr.reverse()     // 直接改變原數組
console.log(arr); // [3,2,1]

arry.slice(start,end)

作用:復制array里的一段內容

/**
 * 有的時候我們想復制數組中的一段元素，但是我們不想改變原數組
 * 就用 arr.slice(start,end)
 * 參數 start 開始索引
 *      end 結束索引
 *      實際獲取的元素是 [start,end) 左閉,右開 ?。?！
 *      基本上所有語言，（start,end）都是這樣的規(guī)定
 */

let arr = [1,2,3];
let temp = arr.slice(0,2);   
console.log(temp);  //[1,2]

array.join(separator)

作用：數組轉字符串，將數組里面的元素拿出來用separator（分隔符）串聯在一起，變成字符串

/**
 * arr.join(separator)
 * 數組轉字符串 把數組的每個元素拿出來，用separator將他們分隔開來
 * 參數 separator 分隔符
 */
let arr = [1,2,3];
let c = arr.join(','); //1,2,3   將arr數組中的元素用逗號分割，并轉換成字符串
console.log(c);

//其實等價于
let str = "";
for (item of arr){
    str += (item+',');
}
str = str.substr(0,str.length-1); //去除掉最后一個逗號
console.log(str);

array.sort(comparefn)

作用：數組排序（并不一定可靠）

var arr1 = [3,2,1];
console.log(arr1.sort()); // 輸出 [1,2,3]
var arr2 = [4,8,15,23];
console.log(arr2.sort()); // 輸出 [15, 23, 4, 8] ？？？
/**
  * 也許聰明的你，已經看出規(guī)律了，
  * arr.sort() 它只排序了比對了數據第一位。
  * arr2,它將8和15做比較大小的時候，是將8和1比較的，
  * 所以，15才會在8前面。
  */

//arr.sort(comparefn) 可以通過接受一個compare參數來進行更加精準排序
arr2.sort(function(a,b){
    return a-b;
});
console.log(arr2); // [4, 8, 15, 23] 此時結果正確了
// 你的比較函數應該接受兩個參數，并且如果兩個參數相等則返回0
// 如果兩個參數不等，且第一個參數排在前面，則返回一個負數
// 如果兩個參數不等，且第二個參數排在前面，則返回一個正數

array.splice(start,deleteCount,item...)

作用：全能王，能同時實現刪除和插入。

// arr.splice(start,deleteCount,item...)
/**
* 參數 start:開始的索引
*       deleteCount : 刪除元素的個數
*       item: 要插入的元素值
* 返回值 被刪除的元素數組
*/

let arr = [1,2,3];
let a = arr.splice(0,1,'test'); //從0開始刪除一個元素，并在這個位置插入元素'test'
console.log(arr); //["test",1,2]
console.log(a); // [1]

Array.isArray(item)

作用：判定一個元素是否是數組

Array.isArray([1, 2, 3]);  
// true
Array.isArray({foo: 123}); 
// false
Array.isArray("foobar");   
// false
Array.isArray(undefined);  
// false

自此，關于數組的常用方法（API) 就學習完了。

Number

number.toString()

作用：數字類型轉字符串

Number.parseInt(item)

作用：將字符串，轉換成整數，當item不是字符串時，會調用tostring方法，把它變成string

Number.parseFloat(item)

作用：將字符串，轉換成浮點數，當item不是字符串時，會調用tostring方法，把它變成string

// 1. 
var num = 3.14;
console.log(num.toString(),typeof num,typeof num.toString());
// 輸出 3.14 number string
// 2.
console.log(Number.parseInt(num));    //3
console.log(Number.parseInt("3.14")); //3 
// 3.
console.log(Number.parseFloat("3.14"),typeof Number.parseFloat("3.14"));
// 輸出 3.14 "number"

Number.isNaN(item)

作用：判定一個數值是否NaN

/**
  * NaN的數據類型是number,它不等于任何值，也不等于它自己
  * console.log(NaN === NaN); //false
*/

Number.isNaN(NaN);        // true
Number.isNaN(Number.NaN); // true
Number.isNaN(0 / 0)       // true

// 下面這幾個如果使用全局的 isNaN() 時，會返回 true。(一定要使用Number.isNaN,而不是 isNaN,會引起如下錯誤)
Number.isNaN("NaN");      // false，字符串 "NaN" 不會被隱式轉換成數字 NaN。
Number.isNaN(undefined);  // false
Number.isNaN({});         // false
Number.isNaN("blabla");   // false

Number.isInteger(item)

作用：判定一個數是否是整數

console.log(Number.isInteger(3)); //true
console.log(Number.isInteger(3.14)); //false
console.log(Number.isInteger(undefined));//false

Object

object.hasOwnProperty(item)

作用：判定對象是否擁有某屬性

var obj = {
    name:"tom",
    age:18
}
console.log(obj.hasOwnProperty("name")); // true
console.log(obj.hasOwnProperty("weigth")); // false

object.keys()

作用：返回對象所有的屬性，作為數組

var obj = {
    name:"tom",
    age:18
}
console.log(Object.keys(obj)); //["name", "age"]

object.values()

作用: 返回對象所有的值，作為數組

var obj = {
    name:"tom",
    age:18
}
console.log(Object.values(obj)); // ["tom", 18]

補充：object的子集JSON

JSON只有兩個方法

JSON.stringify()

作用：返回與指定值對應的JSON字符串。即對象類型轉字符串，常用于數據傳輸。

JSON.parse()

作用：解析JSON字符串并返回對應的值。即字符串轉對象類型，常用于數據傳輸。

這倆在JSON格式的數據傳輸中必不可少。前后端交互少不了它們。

var obj = {
    name: "tom",
    age: 18
}

console.log(JSON.stringify(obj),typeof JSON.stringify(obj));
// {"name":"tom","age":18}  數據類型：string

var str = '{"name":"tom","age":18}';
console.log(JSON.parse(str),typeof JSON.parse(str));
// {name: "tom", age: 18}  數據類型 object

String

string.charAt(pos)

作用：返回字符串在對應索引處的值

var str = "hello";
console.log(str.charAt(0)); // h
console.log(str[0]);        // h 
// 這兩種結果是一樣的，都是返回字符串在對應索引處的值

string.concat(string...)

作用：把字符串連接起來構成一個新的字符串（常用+運算符把它替代）

var str1 = "hello";
var str2 = " world!";
var str = str1.concat(str2);
console.log(str);       //hello world!
console.log(str1+str2); //hello world!
// 建議使用+運算符進行字符串拼接
// 現階段瀏覽器引擎都對+運算符做過優(yōu)化，它的性能并不低

string.indexof(searchString,position)

作用：查找searchString在string 中第一次出現的位置，返回值如果是-1，說明沒找到

string.lastIndexOf(searchString,position)

作用：從末尾開始查找searchString在string 中第一次出現的位置，返回值如果是-1，說明沒找到

var str = "hello world";
console.log(str.indexOf("h")); //0
// 不指定postion,默認postion=0
console.log(str.indexOf("o")); // 4
console.log(str.indexOf("o",5)); // 7

// 從末尾查找
console.log(str.lastIndexOf("o")); //7

// 沒找到返回-1
console.log(str.indexOf("s")); // -1

string.search(regexp)

作用：search方法和indexof方法類似，但是只能接受一個正則表達式作為參數

var str = "hey JudE";
var re = /[A-Z]/g;
var re2 = /[.]/g;
console.log(str.search(re)); // returns 4, 對應的是 "J"
console.log(str.search(re2)); // returns -1，沒能找到 '.'

string.substring(start,end)

作用：截取字符串（缺點參數start,end不能是負數）

string.slice(start,end)

作用：和substring功能類似，但是它的參數start,end 可以接受負數（請盡量使用slice，而不是substring，slice比substring更加強大)

var str = "hello world";
console.log(str.substring(6,str.length)); //world
console.log(str.slice(6,str.length));//world

// 但是substring 不支持 負數
console.log(str.substring(-5,str.length)); // 它會輸出一個不合理的值
console.log(str.slice(-5,str.length)); // world

/**
 * 當時用str.slice 時，-1對應的就是最后一個字符
 * 上例中 
 * -1 對應的是 字母d
 * -2 對應的是倒數第二個 也就是 字母l
 * 請盡量用slice 取代 substring
 */

string.split(separator,limit)

作用：字符串轉數組

/**
 * string.split 
 * 參數介紹：
 *      separator:分隔符
 *      limit: 生成數組元素個數 
 */
var str = "1,2,3";
var arr = str.split(",",2);
console.log(arr); // ["1", "2"]

string.toLowerCase()

作用：字符串全部轉小寫

string.toUpperCase()

作用：字符串全部轉大寫

var str = "Hello WORLD";
console.log(str.toLowerCase()); //hello world
console.log(str.toUpperCase()); //HELLO WORLD

Date

date.toLocaleString()

作用：轉化成本地時間，包含完成的年月日和時分秒。

date.toLocaleDateString()

作用：轉化成本地時間，包含完成的年月日。

date.toLocaleTimeString()

作用：轉化成本地時間，包含完成的時分秒。

var date = new Date();

console.log(date.toLocaleDateString());// 日期 2020/7/23
            
console.log(date.getFullYear()); // 2020
console.log(date.getMonth());    //6
console.log(date.getDate());     // 23

console.log(date.toLocaleTimeString()); //上午10:44:26

console.log(date.getHours());   // 10
console.log(date.getMinutes()); // 44
console.log(date.getSeconds()); // 26

console.log(date.toLocaleString()); // 2020/7/23 上午10:47:45

var date = new Date(2020,01,02,11,11,11); 
// 依次為 年，月，日，時，分，秒
// 2020/2/2 上午11:11:11 實際月份 = 設置的+1
console.log(date.toLocaleString());

好了，這就是全部內容了，如果覺得對你有所幫助的話就點個贊吧。

image

么么噠