返回值是：[1,NaN,NaN]

parseInt與map函數(shù)都是常用的函數(shù)，可是 ["1", "2", "3"].map(parseInt) 為何返回不是[1,2,3]卻是[1,NaN,NaN]？

下面我們先來了解一下parseInt函數(shù)的使用方法。

parseInt() 函數(shù)

parseInt() 函數(shù)解析一個字符串參數(shù)，并返回一個指定基數(shù)的整數(shù) (數(shù)學系統(tǒng)的基礎(chǔ))。

語法

parseInt(string, radix)

返回值

返回解析后的數(shù)字。

說明

當參數(shù) radix 的值為 0，或沒有設(shè)置該參數(shù)時，parseInt() 會根據(jù) string 來判斷數(shù)字的基數(shù)。

一下情況返回值為NaN

• radix 小于 2 或大于 36
• 第一個非空格字符不能轉(zhuǎn)換為數(shù)字。

在 JavaScript 中，可以使用 arguments 對象來實現(xiàn)可變參數(shù)。 arguments 是一個類數(shù)組對象，包含傳遞給函數(shù)的所有參數(shù)。可以在函數(shù)內(nèi)部通過訪問 arguments 對象來訪問所有參數(shù)。

以下是一個使用 arguments 對象實現(xiàn)可變參數(shù)的示例：

function sum() {
    let total = 0;
    for (let i = 0; i < arguments.length; i++) {
        total += arguments[i];
    }
    return total;
}

console.log(sum(1, 2, 3)); // 6
console.log(sum(4, 5, 6, 7)); // 22

在 ES6 中還可以通過擴展運算符來實現(xiàn)可變參數(shù)。

function sum(...numbers) {
    let total = 0;
    for (let i = 0; i < numbers.length; i++) {
        total += numbers[i];
    }
    return total;
}

console.log(sum(1, 2, 3)); // 6
console.log(sum(4, 5, 6, 7)); // 22

在 JavaScript 中，valueOf() 方法是一個可以被對象調(diào)用的方法，用于返回該對象的原始值。它可以被所有對象類型（包括自定義對象）調(diào)用，并返回一個原始值，例如字符串、數(shù)字、布爾值等。

對象

下面是一個示例，展示了在 JavaScript 中對象使用 valueOf() 方法：

let myObj = {
    name: "Quintion",
    age: 30,
    toString() {
        return `${this.name} 年齡 ${this.age}`;
    },
    valueOf() {
        return this.age;
    },
};

console.log(myObj.toString()); // Quintion 年齡 30
console.log(myObj.valueOf()); // 30

數(shù)字

在 JavaScript 中的數(shù)字是 Number 類型的實例，具有 valueOf() 方法，返回一個數(shù)字對象的原始值。

例如，如果有一個數(shù)字對象 num，可以使用 valueOf() 方法獲取它的原始值，如下所示：

const num = new Number(42);
console.log(num.valueOf()); // 42

大多數(shù)情況下，JavaScript 引擎會自動將數(shù)字對象轉(zhuǎn)換為數(shù)字類型，因此通常不需要使用 valueOf() 方法來獲取數(shù)字對象的值。例如：

const num = new Number(42);
const result = num + 10;
console.log(result); // 52

字符串

字符串是 String 類型的實例，也具有 valueOf() 方法，返回一個字符串對象的原始值。

例如，如果有一個字符串對象 str，可以使用 valueOf() 方法獲取它的原始值，如下所示：

const str = new String("hello");
console.log(str.valueOf()); // 'hello'

同樣，JavaScript 引擎會自動將字符串對象轉(zhuǎn)換為字符串類型，因此不需要使用 valueOf() 方法來獲取字符串對象的值。例如：

const str = new String("hello");
const result = str + " world";
console.log(result); // 'hello world'

上面代碼 str 會被自動轉(zhuǎn)換為字符串類型，因此可以將它與另一個字符串連接起來。

在JavaScript中，null 和 undefined 都表示無值（no value）的含義，但是它們在具體使用中有一些不同之處：

1. undefined 表示未定義，即聲明了但未賦值的變量的默認值，或者訪問對象不存在的屬性時返回的值。例如：const x; console.log(x); 輸出 undefined。
2. null 表示空值，即一個變量被明確地賦值為空。例如：const x = null; console.log(x); 輸出null。

雖然它們都表示無值，但在某些情況下，它們是不等價的。例如，使用雙等號（==）比較時，null 和 undefined 會被視為相等的值，但在使用嚴格相等運算符（===）比較時，它們是不相等的。同時，在使用 typeof 運算符時，null 會被視為一個對象，而 undefined 會被視為未定義的變量。

總結(jié)大概如下：

• null 是一個賦值。這沒有任何意義。
• undefined 表示變量已聲明但尚未定義。
• null是一個對象。undefined 是類型 undefined。
• null !== undefined 但是 null == undefined。

本系列開始系統(tǒng)性的對 20 多種 JavaScript 設(shè)計模式進行簡單概述，然后結(jié)合 ES6 類的方式來編寫實例代碼展示其使用方式。

什么是設(shè)計模式？

設(shè)計模式是軟件設(shè)計中常見問題的解決方案，這些模式很容易重復使用并且富有表現(xiàn)力。

在軟件工程中，設(shè)計模式（design pattern）是對軟件設(shè)計中普遍存在（反復出現(xiàn)）的各種問題，所提出的解決方案。它并不直接用來完成代碼的編寫，而是描述在各種不同情況下，要怎么解決問題的一種方案。面向?qū)ο笤O(shè)計模式通常以類別或?qū)ο髞砻枋銎渲械年P(guān)系和相互作用，但不涉及用來完成應(yīng)用程序的特定類別或?qū)ο蟆?mdash;— 維基百科

有三種模式：創(chuàng)建型模式，結(jié)構(gòu)型模式、行為型模式。

• 創(chuàng)建型模式：解決與創(chuàng)建對象相關(guān)的問題。
• 結(jié)構(gòu)型模式：處理實體之間的關(guān)系，以及它們?nèi)绾喂餐M成一個更大的結(jié)構(gòu)。
• 行為型模式：處理對象如何相互通信和交互。

設(shè)計模式系列文章：

• 《ES6 類聊 JavaScript 設(shè)計模式之結(jié)構(gòu)型模式》
• 《ES6 類聊 JavaScript 設(shè)計模式之行為型模式（一）》
• 《 ES6 類聊 JavaScript 設(shè)計模式之行為型模式（二）》
• 《JavaScript 設(shè)計模式之代理模式》
• 《JavaScript 設(shè)計模式之策略模式》

在 ES6 中，可以使用閉包來模擬私有變量的實現(xiàn)。具體地說，可以使用一個立即執(zhí)行函數(shù)表達式 IIFE 來創(chuàng)建一個函數(shù)作用域，在函數(shù)作用域內(nèi)定義私有變量，然后通過返回一個對象，使得外部無法直接訪問私有變量。

例如，以下是一個使用閉包實現(xiàn)私有變量的示例：

const Counter = (() => {
    let count = 0; // 私有變量

    return {
        increment() {
            count++;
            console.log(`count: ${count}`);
        },
        reset() {
            count = 0;
            console.log("count reset");
        },
    };
})();

Counter.increment(); // 輸出 "count: 1"
Counter.increment(); // 輸出 "count: 2"
Counter.reset(); // 輸出 "count reset"

在上述示例中，count 變量是私有的，外部無法直接訪問它，但是可以通過調(diào)用返回的對象中的方法來操作它。這里使用了箭頭函數(shù)和對象字面量來定義返回的對象，使得代碼更加簡潔。

HTTP Cookie（也叫 Web Cookie 或瀏覽器 Cookie）是服務(wù)器發(fā)送到用戶瀏覽器并保存在本地的一小塊數(shù)據(jù)，它會在瀏覽器下次向同一服務(wù)器再發(fā)起請求時被攜帶并發(fā)送到服務(wù)器上。是WEB項目開發(fā)需要涉及的內(nèi)容。

Cookie操作

如果應(yīng)用程序是完全客戶端 SPA（單頁應(yīng)用程序），可能不需要 cookie，使用 localStorage 可以解決問題。如果是使用 Next.js 或者 Node.js 提供服務(wù)器接口需要身份驗證 Token 的可以考慮使用 cookie。

通常認為 cookie 是復數(shù)形式，但事實是它們存儲在單個字符串值中，必須對其進行解析才能將它們分解為單獨的鍵/值對。

console.log(document.cookie); // _gcl_au=1.1.1660316496.1636468606; _ga=GA1.2.221099298.1636468607; _gid=GA1.2.1474751041.1636468607;

可以通過 ; 拆分字符串來將它們分開，然后映射每個值并使用 = 將其拆分為 ，最終將得到相應(yīng)的鍵/值對。下面是一個完整的方法集：

const useCookie = (options = { days: 30, path: "/" }) => {
    const { days: expiresDays, path: cookiePath } = options;

    const set = (name, value) => {
        const exp = new Date();
        exp.setTime(exp.getTime() + expiresDays * 24 * 60 * 60 * 1000);
        const strExpires = exp.toGMTString();
        const cookieValue = escape(value);
        document.cookie = `${name}=${cookieValue};expires=${strExpires};path=${cookiePath}`;
    };
    const get = (name) => {
        let arr;
        const reg = new RegExp("(^| )" + name + "=([^;]*)(;|$)");
        if ((arr = document.cookie.match(reg))) {
            return unescape(arr[2]);
        } else {
            return null;
        }
    };
    // 刪除cookie
    const remove = (name) => {
        document.cookie = name + "=;expires=" + new Date(0).toGMTString();
    };
    // 清除所有 cookie
    const clear = () =>
        document.cookie
            .split(";")
            .forEach(
                (cookie) =>
                    (document.cookie = cookie
                        .replace(/^ +/, "")
                        .replace(
                            /=.*/,
                            `=;expires=${new Date().toUTCString()};path=${cookiePath}}`
                        ))
            );
    /**
     * 獲取所有的 cookie
     * @returns
     */
    const all = () =>
        document.cookie
            .split(";")
            .map((item) => item.split("="))
            .reduce(
                (acc, [k, v]) => (acc[k.trim().replace('"', "")] = v) && acc,
                {}
            );
    return {
        set,
        get,
        clear,
        remove,
        all,
    };
};
const cookieHelper = useCookie();
cookieHelper.set("name", "DevPoint");
cookieHelper.set("city", "Shenzhen");
console.log(cookieHelper.get("name")); // DevPoint
console.log(cookieHelper.all()); // { name: "DevPoint", city: "Shenzhen" }
cookieHelper.remove("name");
console.log(cookieHelper.all()); // { city: "Shenzhen" }

出于安全考慮，某些 cookie 可能被標記為 僅 HTTP ，這意味著此類 cookie 不能從客戶端的 JavaScript 代碼中獲取到。

Cookie 安全

Cookie 安全主要涉及以下兩個方面：

防止竊取

攻擊者可以通過竊取用戶的 Cookie 來實現(xiàn)會話劫持等攻擊，因此在設(shè)置 Cookie 時應(yīng)當注意以下安全問題：

• 在服務(wù)器端設(shè)置 HttpOnly 屬性，防止腳本獲取 Cookie。
• 使用 secure 屬性，只允許在 HTTPS 連接中傳輸 Cookie。
• 設(shè)置 SameSite 屬性，防止跨站請求偽造攻擊（CSRF）。

防止篡改
攻擊者還可以通過修改 Cookie 的值來實現(xiàn)攻擊，因此在使用 Cookie 時應(yīng)當注意以下安全問題：

• 在服務(wù)器端對 Cookie 的值進行加密和簽名，防止篡改。
• 對于關(guān)鍵操作，應(yīng)當在服務(wù)端進行校驗，避免因為 Cookie 被篡改而造成安全漏洞。

綜上所述，Cookie 安全需要從多個方面進行考慮和防護。

Cookie 和 Token

應(yīng)用開發(fā)一般都少不了身份驗證，而身份驗證機制的穩(wěn)定性對所有應(yīng)用程序都變得至關(guān)重要。具體選擇何種方式進行身份驗證可以根據(jù)項目及團隊情況來衡量，在決定之前需要先理解WEB身份驗證常見的兩種方式：基于 Cookie 的身份驗證和基于令牌（Token）的身份驗證。

以下是一個將字符串轉(zhuǎn)換為二進制字符串的 JavaScript 函數(shù)：

function stringToBinary(string) {
    let binaryString = "";
    for (let i = 0; i < string.length; i++) {
        // 將字符轉(zhuǎn)換為 Unicode 編碼
        const charCode = string.charCodeAt(i);
        // 將 Unicode 編碼轉(zhuǎn)換為二進制字符串
        const charBinary = charCode.toString(2);
        // 將二進制字符串補齊 8 位
        const paddedCharBinary = charBinary.padStart(8, "0");
        // 將每個字符的二進制字符串拼接到總的二進制字符串中
        binaryString += paddedCharBinary;
    }
    return binaryString;
}

函數(shù)接受一個字符串作為參數(shù)，返回一個二進制字符串。通過遍歷字符串中的每個字符，將其轉(zhuǎn)換為 Unicode 編碼，再將 Unicode 編碼轉(zhuǎn)換為二進制字符串，最后將每個字符的二進制字符串拼接到總的二進制字符串中。如果一個字符的二進制字符串不足 8 位，函數(shù)會在左側(cè)用 0 填充，使其成為 8 位二進制字符串。

使用方法如下：

const chineseString = stringToBinary("全棧工匠");
console.log(chineseString); // 101000101101000110100000001000101110111100101101001100100000
const englishString = stringToBinary("hu");
console.log(englishString); // 0110100001110101

JavaScript 可以使用以下代碼實現(xiàn)進制轉(zhuǎn)換：

1、十進制轉(zhuǎn)二進制

使用 toString() 方法，將十進制數(shù)轉(zhuǎn)換為二進制字符串，如下：

const decimalToBinary = (decimalNumber) => decimalNumber.toString(2);

console.log(decimalToBinary(11)); // 1011

2、十進制轉(zhuǎn)八進制

const decimalToOctal = (decimalNumber) => decimalNumber.toString(8);

console.log(decimalToOctal(11)); // 13

3、十進制轉(zhuǎn)十六進制

const decimalToHex = (decimalNumber) => decimalNumber.toString(16);

console.log(decimalToHex(11)); // b

4、二進制轉(zhuǎn)十進制

const binaryToDecimal = (binaryString) => parseInt(binaryString, 2);

console.log(binaryToDecimal(1011)); // 11

5、八進制轉(zhuǎn)十進制

const octalToDecimal = (binaryString) => parseInt(binaryString, 8);

console.log(octalToDecimal(13)); // 11

6、十六進制轉(zhuǎn)十進制

const hexToDecimal = (binaryString) => parseInt(binaryString, 16);

console.log(hexToDecimal("b")); // 11

7、二進制轉(zhuǎn)十六進制

const binaryToHex = (binaryString) => {
    const decimalNumber = parseInt(binaryString, 2);
    return decimalNumber.toString(16);
};

console.log(binaryToHex(1011)); // b

8、八進制轉(zhuǎn)二進制

const octalToBinary = (octalString) => {
    const decimalNumber = parseInt(octalString, 8);
    return decimalNumber.toString(2);
};

console.log(octalToBinary(13)); // 1011

9、十六進制轉(zhuǎn)二進制

const hexToBinary = (hexString) => {
    const decimalNumber = parseInt(hexString, 16);
    return decimalNumber.toString(2);
};

console.log(hexToBinary("b")); // 1011

10、八進制轉(zhuǎn)十六進制

const octalToHex = (octalString) => {
    const decimalNumber = parseInt(octalString, 8);
    return decimalNumber.toString(16);
};

console.log(octalToHex(13)); // b

下面將上述代碼封裝成一個類，完整代碼如下：

class NumberConverter {
    static decimalToBinary(decimalNumber) {
        return decimalNumber.toString(2);
    }

    static decimalToOctal(decimalNumber) {
        return decimalNumber.toString(8);
    }

    static decimalToHex(decimalNumber) {
        return decimalNumber.toString(16);
    }

    static binaryToDecimal(binaryString) {
        return parseInt(binaryString, 2);
    }

    static octalToDecimal(octalString) {
        return parseInt(octalString, 8);
    }

    static hexToDecimal(hexString) {
        return parseInt(hexString, 16);
    }

    static binaryToHex(binaryString) {
        const decimalNumber = parseInt(binaryString, 2);
        return decimalNumber.toString(16);
    }

    static octalToBinary(octalString) {
        const decimalNumber = parseInt(octalString, 8);
        return decimalNumber.toString(2);
    }

    static hexToBinary(hexString) {
        const decimalNumber = parseInt(hexString, 16);
        return decimalNumber.toString(2);
    }

    static octalToHex(octalString) {
        const decimalNumber = parseInt(octalString, 8);
        return decimalNumber.toString(16);
    }
}

console.log(NumberConverter.decimalToBinary(11)); // 1011
console.log(NumberConverter.decimalToOctal(11)); // 13

每天學習10個實用JavaScript代碼片段，加深對 JavaScript 語法的理解，積累代碼優(yōu)化經(jīng)驗。

1、FizzBuzz

下面代碼用于實現(xiàn)經(jīng)典的 FizzBuzz 問題，將1到100的數(shù)字遍歷，如果是3的倍數(shù)則輸出 Fizz ，如果是5的倍數(shù)則輸出 Buzz，如果既是3的倍數(shù)又是5的倍數(shù)則輸出 FizzBuzz。

const fizzBuzz = () => {
    for (let i = 1; i <= 100; )
        console.log((i % 3 ? "" : "Fizz") + (i % 5 ? "" : "Buzz") || i), i++;
};
console.log(fizzBuzz());

2、斐波那契數(shù)列

斐波那契數(shù)列（Fibonacci sequence），又稱黃金分割數(shù)列，因數(shù)學家萊昂納多·斐波那契（Leonardo Fibonacci）以兔子繁殖為例子而引入，故又稱為“兔子數(shù)列”，指的是這樣一個數(shù)列：1、1、2、3、5、8、13、21、34、…… 在數(shù)學上，斐波那契數(shù)列以如下被以遞推的方法定義：F(0)=1，F(xiàn)(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*），在現(xiàn)代物理、準晶體結(jié)構(gòu)、化學等領(lǐng)域，斐波那契數(shù)列都有直接的應(yīng)用

斐波那契數(shù)列通常是面試常見的問題，下面代碼是用一個非常簡短的遞歸函數(shù)，返回斐波那契數(shù)列中第n個數(shù)字的值。

const fib = (n) => (n <= 2 ? 1 : fib(n - 1) + fib(n - 2));

const createFibNumber = (count = 10) => {
    const arrayFibs = [];
    for (let i = 0; i < count; i++) {
        arrayFibs.push(fib(i));
    }
    return arrayFibs;
};

console.log(createFibNumber(10)); // [ 1, 1,  1,  2,  3, 5, 8, 13, 21, 34 ]

3、快速排序

下面代碼實現(xiàn)了快速排序，通過遞歸將數(shù)組分割成較小和較大的兩個子數(shù)組，最終將它們合并以獲得排序的結(jié)果。

const quickSort = (arrayNums) =>
    arrayNums.length
        ? [
              ...quickSort(arrayNums.slice(1).filter((x) => x <= arrayNums[0])),
              arrayNums[0],
              ...quickSort(arrayNums.slice(1).filter((x) => x > arrayNums[0])),
          ]
        : [];

const arrayNumbers = [1, 3, 5, 6, 2, 4, 11, 30, 100, 40];
console.log(quickSort(arrayNumbers)); // [ 1,  2,  3,  4,   5, 6, 11, 30, 40, 100 ]

4、判斷是否為回文

下面代碼用于判斷一個字符串是否為回文，它將字符串轉(zhuǎn)換為一個字符數(shù)組并翻轉(zhuǎn)它，然后將它們重新連接起來，并將其與原字符串進行比較。

const isPalindrome = (str) => str == str.split("").reverse().join("");

console.log(isPalindrome("deved")); // true
console.log(isPalindrome("devedev")); // false

5、數(shù)組去重

下面代碼用于對一個數(shù)組進行去重操作，使用ES6中的Set數(shù)據(jù)結(jié)構(gòu)，將數(shù)組轉(zhuǎn)換為一個Set，然后再將其轉(zhuǎn)換為一個數(shù)組。

const unique = (arr) => [...new Set(arr)];

const arrayNumbers = [1, 2, 3, 4, 2, 1];
console.log(unique(arrayNumbers)); // [ 1, 2, 3, 4 ]

6、打印九九乘法表

下面代碼可以打印出九九乘法表，它通過兩個嵌套的for循環(huán)遍歷每個數(shù)字，然后打印出相應(yīng)的乘法表達式及其結(jié)果。

const createNumbers = () => {
    const array = [];
    for (let i = 1; i <= 9; i++)
        for (let j = 1; j <= i; j++)
            array.push(`${j}*${i}=${j * i}${j === i ? "\n" : "  "}`);
    return array.join("");
};
console.log(createNumbers());

輸出結(jié)果如下：

1*1=1
1*2=2  2*2=4
1*3=3  2*3=6  3*3=9
1*4=4  2*4=8  3*4=12  4*4=16
1*5=5  2*5=10  3*5=15  4*5=20  5*5=25
1*6=6  2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
1*7=7  2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
1*8=8  2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
1*9=9  2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81

7、數(shù)組求和

下面代碼用于對一個數(shù)組中的數(shù)字進行求和，使用 reduce 方法將數(shù)組中的所有數(shù)字相加起來，并返回最終的結(jié)果。

const sum = (arr) => arr.reduce((acc, current) => acc + current, 0);
console.log(sum([1, 3, 5, 7, 9, 10])); // 35

8、獲取URL參數(shù)

下面代碼用于從URL中獲取特定的參數(shù)值，使用 URLSearchParams API來獲取URL查詢參數(shù)，并使用get方法獲取特定的參數(shù)值。

const getParam = (url, name) =>
    new URLSearchParams(new URL(url).search).get(name);

console.log(getParam("http://www.zlot.com.cn?name=devpoint", "name")); // devpoint

9、判斷一個數(shù)字是否為質(zhì)數(shù)

下面代碼用于判斷一個數(shù)字是否為質(zhì)數(shù)，使用一個for循環(huán)遍歷2到數(shù)字的平方根之間的所有數(shù)字，并檢查它們是否可以整除該數(shù)字。

const isPrime = (n) => {
    if (n <= 1) return false;
    for (let i = 2; i <= Math.sqrt(n); i++) {
        if (n % i === 0) return false;
    }
    return true;
};
console.log(isPrime(1)); // false
console.log(isPrime(2)); // true
console.log(isPrime(3)); // true

10、數(shù)組扁平化

下面代碼用于將一個嵌套的數(shù)組扁平化為一個一維數(shù)組，使用 reduce 方法遞歸地遍歷嵌套數(shù)組，并將其合并為一個新的數(shù)組。

const flatten = (arr) =>
    arr.reduce(
        (acc, val) => acc.concat(Array.isArray(val) ? flatten(val) : val),
        []
    );

console.log(flatten([1, [1, 3], [4, 5, 6], [7, [8, [9]]]])); // [ 1, 1, 3, 4, 5, 6, 7, 8, 9 ]

11、階乘

下面代碼用于計算一個數(shù)字的階乘，使用遞歸方法，將數(shù)字乘以它減一的階乘。

const factorial = (n) => (n < 2 ? 1 : n * factorial(n - 1));
console.log(factorial(4)); // 24

總結(jié)

閱讀開源項目是學習提升編碼能力最快捷的方式，當然現(xiàn)在可能可以借助 ChatGPT 來生成一些函數(shù)，其生成的函數(shù)技巧性也很高。

在 JavaScript 中，可以使用 substr()、slice() 和 substring() 方法截取字符串。

substring()

substring() 方法返回一個字符串在開始索引到結(jié)束索引之間的一個子集，或從開始索引直到字符串的末尾的一個子集。語法如下：

str.substring(indexStart[, indexEnd])

參數(shù)說明：

• indexStart：需要截取的第一個字符的索引，該索引位置的字符作為返回的字符串的首字母。
• indexEnd：可選。一個 0 到字符串長度之間的整數(shù)，以該數(shù)字為索引的字符不包含在截取的字符串內(nèi)。

如果 startIndex 大于 endIndex，則會交換它們的位置。來看一段示例代碼：

let str = "深耕WEB開發(fā)10+年，擁有一顆工匠的心";

console.log(str.substring(7)); // 10+年，擁有一顆工匠的心
console.log(str.substring(0, 5)); // 深耕WEB
console.log(str.substring(7, 5)); // 開發(fā)
console.log(str.substring(5, 5)); // 空

substr()

substr() 方法返回一個字符串中從指定位置開始到指定字符數(shù)的字符。語法如下：

str.substr(start[, length])

第一個參數(shù)是截取開始的位置，第二個參數(shù)是截取的長度。如下代碼：

let str = "深耕WEB開發(fā)10+年，擁有一顆工匠的心";
let result = str.substr(1, 4);
console.log(result); // 耕WEB

上述代碼的 1 表示從第二個字符開始截取，4 表示截取的長度為 4 個字符。

substr() 方法在截取字符串時是基于字符位置的，如果截取長度超過了字符串的長度，它會一直截取到字符串的末尾。如果第一個參數(shù)是負數(shù)，則從字符串的末尾開始計數(shù)。

如果可以的話，建議使用 substring() 來取代 substr()。

slice()

slice() 方法提取某個字符串的一部分，并返回一個新的字符串，且不會改動原字符串，與 substring() 方法類似。語法如下：

str.slice(startIndex, endIndex)

其中，startIndex 表示要截取的子字符串的起始位置（包含該位置），endIndex 表示要截取的子字符串的結(jié)束位置（不包含該位置）。如果只傳入 startIndex，則會從該位置一直截取到字符串末尾。如果 startIndex 大于 endIndex，則會返回空字符串。例如：

let str = "深耕WEB開發(fā)10+年，擁有一顆工匠的心";

console.log(str.slice(7)); // 10+年，擁有一顆工匠的心
console.log(str.slice(0, 5)); // 深耕WEB
console.log(str.slice(7, 5)); // ""
console.log(str.slice(5, 5)); // ""

substring() 和 substr() 的區(qū)別

substring() 和 substr() 都是截取字符串的方法，但它們有以下區(qū)別：

1. 參數(shù)不同：substring() 方法的第一個參數(shù)是起始位置，第二個參數(shù)是終止位置（不包括該位置的字符）；substr() 方法的第一個參數(shù)是起始位置，第二個參數(shù)是截取的長度。
2. 負數(shù)處理不同：substring() 方法不接受負數(shù)參數(shù)，如果傳入負數(shù)，會被自動轉(zhuǎn)換為0；substr() 方法可以接受負數(shù)參數(shù)，表示倒數(shù)計數(shù)。
3. 返回值不同：substring() 方法返回從起始位置到終止位置之間的字符；substr()方法返回從起始位置開始指定長度的字符。

ES6中新增了 slice() 方法，但它和 substring() 方法非常相似，也是接受起始位置和終止位置作為參數(shù)，不同之處是slice() 方法可以接受負數(shù)參數(shù)，表示從字符串末尾開始計數(shù)。substr() 雖然沒有被完全遺棄，但還是建議使用 substring() 來取代 substr()。

WebAssembly（縮寫為WASM）是一種二進制格式的代碼，它可以在現(xiàn)代Web瀏覽器中運行。它被設(shè)計為一種低級的虛擬機，可以在瀏覽器中運行高性能的程序，可以通過編譯其他語言的代碼來實現(xiàn)。

下面是WebAssembly可以做的一些事情：

• 前端開發(fā)：WebAssembly 可以與JavaScript一起使用，以提高Web應(yīng)用程序的性能。例如，可以使用WebAssembly編寫一些計算密集型的算法，以替代JavaScript來提高性能。
• 游戲開發(fā)：可以用于在Web瀏覽器中運行游戲。它可以提供比JavaScript更快的運行速度和更好的性能，使得在Web瀏覽器中運行的游戲更加流暢。
• 跨平臺開發(fā)：可以在不同的平臺上運行，包括Web瀏覽器、桌面和移動設(shè)備。這使得開發(fā)人員可以使用相同的代碼來創(chuàng)建跨平臺應(yīng)用程序。
• 數(shù)據(jù)科學和機器學習：可以用于加速數(shù)據(jù)科學和機器學習應(yīng)用程序，使得這些應(yīng)用程序可以在Web瀏覽器中運行。

除了上述提到的應(yīng)用場景，WebAssembly還有以下幾個優(yōu)點：

• 高性能：WebAssembly代碼可以編譯成原生代碼，因此它可以提供比JavaScript更快的運行速度和更好的性能。這使得它非常適合執(zhí)行計算密集型的任務(wù)，如圖形處理、音視頻處理和機器學習等。
• 安全性：WebAssembly是一種沙箱化的執(zhí)行環(huán)境，因此它可以提供比JavaScript更高的安全性。它的指令集是基于棧的，而不是基于寄存器的，這使得它更難受到緩沖區(qū)溢出等安全漏洞的攻擊。
• 可移植性：WebAssembly可以在不同的平臺上運行，包括Web瀏覽器、桌面和移動設(shè)備。這使得開發(fā)人員可以使用相同的代碼來創(chuàng)建跨平臺應(yīng)用程序，從而減少了開發(fā)時間和成本。
• 擴展性：WebAssembly可以與現(xiàn)有的Web技術(shù)（如JavaScript、CSS和HTML）集成使用，從而可以擴展Web應(yīng)用程序的功能和性能。

WebAssembly 雖然是一門新的技術(shù)，但現(xiàn)在有不少區(qū)塊鏈項目在使用，用來編寫智能合約，提高智能合約的性能和安全性。

下面是一些使用WebAssembly的區(qū)塊鏈項目：

• EOSIO：EOSIO是一個開源的區(qū)塊鏈平臺，可以用于創(chuàng)建高性能的去中心化應(yīng)用程序。它使用WebAssembly作為其智能合約的執(zhí)行引擎，從而提高了智能合約的性能和安全性。
• NEAR Protocol：NEAR Protocol是一個區(qū)塊鏈平臺，旨在為開發(fā)者提供易于使用、高性能和安全的去中心化應(yīng)用程序。它使用WebAssembly作為其智能合約的執(zhí)行引擎，并提供了一些工具和框架來幫助開發(fā)者編寫和部署WebAssembly智能合約。
• Solana：Solana是一個高性能的區(qū)塊鏈平臺，可以處理數(shù)千個交易，每秒鐘處理數(shù)百萬個交易。它使用WebAssembly作為其智能合約的執(zhí)行引擎，從而實現(xiàn)高性能的智能合約執(zhí)行。

從 2022 IEEE 編程語言榜單結(jié)果來看，Python 再次摘得桂冠 ，前 10 的排名如下：

1. Python
2. C
3. C++
4. C#
5. Java
6. SQL
7. JavaScript
8. R
9. HTML
10. TypeScript

python

Python 是一種高級編程語言，由 Guido van Rossum 于 1989 年創(chuàng)造。Python 旨在提供一種簡單、易于閱讀和編寫的語言，同時也具備強大的功能和擴展性，可以用于多種應(yīng)用程序開發(fā)，包括 Web 應(yīng)用程序、游戲開發(fā)、數(shù)據(jù)分析、科學計算等領(lǐng)域。

Python 具有許多特性，包括：

• 簡單易學：其語法簡單易懂，容易學習和上手。
• 可讀性強：采用簡潔的語法和縮進來表示代碼塊，使得代碼易于閱讀和理解。
• 面向?qū)ο?/strong>：支持面向?qū)ο缶幊蹋梢远x類和對象，使得代碼組織更加清晰和靈活。
• 豐富的標準庫：Python 有一個豐富的標準庫，包含了大量的模塊和函數(shù)，可以方便地完成各種任務(wù)。
• 跨平臺性：Python 可以在多種操作系統(tǒng)和平臺上運行，包括 Windows、Mac、Linux 等。
• 強大的第三方庫支持：Python 有大量的第三方庫和框架，可以方便地擴展和增強 Python 的功能。