programming javascript

Đâu là giải pháp thay thế an toàn cho việc sử dụng eval() JavaScript?

Mã được đánh giá gián tiếp luôn cẩu thả. Đó là hệ quả của việc mã được đánh giá độc lập với môi trường xung quanh hiện tại của nó

    function strictFunc[] {
        'use strict';

        var code = '[function [] { return this }[]]';
        var result = eval.call[null, code];
        console.log[result !== undefined]; // true, sloppy mode
    }

Hàm xây dựng có chữ ký

    new Function[param1, ..., paramN, funcBody]

Nó tạo ra một hàm có 0 hoặc nhiều tham số có tên param1, v.v. và cơ thể của ai là funcBody. Đó là, chức năng tạo ra trông như thế này.

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

Ví dụ.

    > var f = new Function['x', 'y', 'return x+y'];
    > f[3, 4]
    7

Tương tự như eval[] gián tiếp, new Function[] tạo các hàm có phạm vi toàn cục.

    > var a = 12;
    > eval['a + 5']
    17

0Các chức năng như vậy cũng cẩu thả theo mặc định.

    > var a = 12;
    > eval['a + 5']
    17

eval[] so với Hàm mới[]

Thông thường, sử dụng Hàm mới [] sẽ tốt hơn so với eval [] để đánh giá mã. Các tham số hàm cung cấp một giao diện rõ ràng cho mã được đánh giá và bạn không cần cú pháp hơi khó xử của hàm eval[] gián tiếp để đảm bảo rằng mã được đánh giá chỉ có thể truy cập các biến toàn cục và của chính nó

Thực hành tốt nhất

Bạn nên tránh eval[] và new Function[]. Tự động đánh giá mã chậm và có nguy cơ bảo mật tiềm ẩn. Nó cũng ngăn hầu hết các công cụ [chẳng hạn như IDE] sử dụng phân tích tĩnh xem xét mã

Thông thường, có những lựa chọn thay thế tốt hơn. Ví dụ: Brendan Eich gần đây đã tweet một anti-pattern được sử dụng bởi các lập trình viên muốn truy cập một thuộc tính có tên được lưu trữ trong biến propName

    > var a = 12;
    > eval['a + 5']
    17

2Ý tưởng có ý nghĩa. Toán tử dấu chấm chỉ hỗ trợ các khóa thuộc tính cố định, được cung cấp tĩnh. Nhưng trong trường hợp này, khóa thuộc tính chỉ được biết khi chạy, đó là lý do cần có eval[] để sử dụng toán tử đó. May mắn thay, JavaScript cũng có toán tử dấu ngoặc, chấp nhận các khóa thuộc tính động. Do đó, sau đây là phiên bản tốt hơn của đoạn mã trên.

    > var a = 12;
    > eval['a + 5']
    17

3Bạn cũng không nên sử dụng eval[] hoặc new Function[] để phân tích dữ liệu JSON. đó là không an toàn. Dựa vào hỗ trợ tích hợp của ECMAScript 5 cho JSON [3] hoặc sử dụng thư viện

Trường hợp sử dụng hợp pháp. Có một vài trường hợp sử dụng hợp pháp, mặc dù nâng cao, cho eval[] và Hàm mới[]. dữ liệu cấu hình với các chức năng [mà JSON không cho phép], thư viện mẫu, trình thông dịch, dòng lệnh và hệ thống mô-đun

Phần kết luận

Đây là tổng quan tương đối cao về đánh giá mã động trong JavaScript. Nếu muốn tìm hiểu sâu hơn, bạn có thể xem qua bài viết “Global eval. Các lựa chọn là gì?”

Nhìn nhận. Mariusz Nowak [@medikoo] nói với tôi rằng mã được đánh giá bởi Hàm theo mặc định là cẩu thả, ở mọi nơi

Cảnh báo. Thực thi JavaScript từ một chuỗi là một rủi ro bảo mật rất lớn. Quá dễ dàng để một kẻ xấu chạy mã tùy ý khi bạn sử dụng

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5. Xem bên dưới

Hàm

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 đánh giá mã JavaScript được biểu thị dưới dạng chuỗi và trả về giá trị hoàn thành của nó. Nguồn được phân tích cú pháp dưới dạng tập lệnh

    new Function[param1, ..., paramN, funcBody]

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

Một chuỗi đại diện cho một biểu thức JavaScript, câu lệnh hoặc chuỗi các câu lệnh. Biểu thức có thể bao gồm các biến và thuộc tính của các đối tượng hiện có. Nó sẽ được phân tích cú pháp dưới dạng tập lệnh, do đó, khai báo

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

8 [chỉ có thể tồn tại trong mô-đun] không được phép

Giá trị hoàn thành của việc đánh giá mã đã cho. Nếu giá trị hoàn thành trống,

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

9 được trả về. Nếu

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

7 không phải là một chuỗi nguyên thủy, thì

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 trả về đối số không thay đổi

Ném bất kỳ ngoại lệ nào xảy ra trong quá trình đánh giá mã, bao gồm cả

    new Function[param1, ..., paramN, funcBody]

62 nếu

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

7 không được phân tích cú pháp dưới dạng tập lệnh

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 là một thuộc tính chức năng của đối tượng toàn cầu

Đối số của hàm

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 là một chuỗi. Nó sẽ đánh giá chuỗi nguồn dưới dạng phần thân tập lệnh, có nghĩa là cả câu lệnh và biểu thức đều được phép. Nó trả về giá trị hoàn thành của mã. Đối với các biểu thức, đó là giá trị mà biểu thức đánh giá. Nhiều câu lệnh và khai báo cũng có giá trị hoàn thành, nhưng kết quả có thể gây bất ngờ [ví dụ: giá trị hoàn thành của một phép gán là giá trị được gán, nhưng giá trị hoàn thành của

    new Function[param1, ..., paramN, funcBody]

66 là không xác định], vì vậy bạn không nên dựa vào các câu lệnh'

Ở chế độ nghiêm ngặt, việc khai báo một biến có tên là

    new Function[param1, ..., paramN, funcBody]

67 hoặc gán lại cho

    new Function[param1, ..., paramN, funcBody]

67 là một biến

    new Function[param1, ..., paramN, funcBody]

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

Nếu đối số của

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 không phải là một chuỗi, thì

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 trả về đối số không thay đổi. Trong ví dụ sau, việc truyền đối tượng

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

72 thay vì đối tượng nguyên thủy khiến

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 trả về đối tượng

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

72 thay vì đánh giá chuỗi

________số 8

Để giải quyết vấn đề theo cách chung chung, bạn có thể tự mình giải quyết trước khi chuyển cho

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

    new Function[param1, ..., paramN, funcBody]

Có hai chế độ của cuộc gọi

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5. đánh giá trực tiếp và đánh giá gián tiếp. Đánh giá trực tiếp chỉ có một hình thức.

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

77 [tên của hàm được gọi là

    new Function[param1, ..., paramN, funcBody]

67 và giá trị của nó là hàm

    new Function[param1, ..., paramN, funcBody]

67 toàn cầu]. Mọi thứ khác, bao gồm cả việc gọi nó thông qua biến bí danh, thông qua quyền truy cập thành viên hoặc biểu thức khác hoặc thông qua toán tử chuỗi tùy chọn

    > var f = new Function['x', 'y', 'return x+y'];
    > f[3, 4]
    7

70, đều là gián tiếp

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

Đánh giá gián tiếp có thể được xem như thể mã được đánh giá trong một thẻ

    > var f = new Function['x', 'y', 'return x+y'];
    > f[3, 4]
    7

71 riêng biệt. Điều này có nghĩa là

Giá trị gián tiếp hoạt động trong phạm vi toàn cầu thay vì phạm vi cục bộ và mã được đánh giá không có quyền truy cập vào các biến cục bộ trong phạm vi mà nó được gọi
```
    > var f = new Function['x', 'y', 'return x+y'];
    > f[3, 4]
    7
```
7
Gián tiếp
```
    new Function[param1, ..., paramN, funcBody]
```
67 sẽ không kế thừa tính nghiêm ngặt của ngữ cảnh xung quanh và sẽ chỉ ở chế độ nghiêm ngặt nếu bản thân chuỗi nguồn có chỉ thị
```
    > var f = new Function['x', 'y', 'return x+y'];
    > f[3, 4]
    7
```
73
```
    > var a = 12;
    > eval['a + 5']
    17
```
3
Mặt khác, eval trực tiếp kế thừa tính nghiêm ngặt của ngữ cảnh gọi
```
    > var a = 12;
    > eval['a + 5']
    17
```
4
Các khai báo hàm và biến được khai báo
```
    > var f = new Function['x', 'y', 'return x+y'];
    > f[3, 4]
    7
```
74 sẽ đi vào phạm vi xung quanh nếu chuỗi nguồn không được diễn giải ở chế độ nghiêm ngặt - đối với eval gián tiếp, chúng trở thành biến toàn cục. Nếu đó là một eval trực tiếp trong ngữ cảnh chế độ nghiêm ngặt hoặc nếu chính chuỗi nguồn
```
    new Function[param1, ..., paramN, funcBody]
```
67 ở chế độ nghiêm ngặt, thì khai báo hàm và
```
    > var f = new Function['x', 'y', 'return x+y'];
    > f[3, 4]
    7
```
74 không "rò rỉ" vào phạm vi xung quanh
```
    > var a = 12;
    > eval['a + 5']
    17
```
8
Các khai báo
```
    new Function[param1, ..., paramN, funcBody]
```
66 và
```
    > var f = new Function['x', 'y', 'return x+y'];
    > f[3, 4]
    7
```
78 trong chuỗi được đánh giá luôn nằm trong phạm vi của tập lệnh đó
Đánh giá trực tiếp có thể có quyền truy cập vào các biểu thức theo ngữ cảnh bổ sung. Ví dụ, trong phần thân của hàm, người ta có thể sử dụng
```
    > var f = new Function['x', 'y', 'return x+y'];
    > f[3, 4]
    7
```
79
```
    > var a = 12;
    > eval['a + 5']
    17
```
2

Sử dụng trực tiếp

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 bị nhiều vấn đề

```
eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4
```
5 thực thi mã mà nó được chuyển với các đặc quyền của người gọi. Nếu bạn chạy
```
eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4
```
5 với một chuỗi có thể bị ảnh hưởng bởi một bên độc hại, bạn có thể sẽ chạy mã độc hại trên máy của người dùng với quyền của trang web/tiện ích mở rộng của bạn. Quan trọng hơn, việc cho phép mã của bên thứ ba truy cập vào phạm vi mà trong đó
```
eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4
```
5 được gọi [nếu đó là một đánh giá trực tiếp] có thể dẫn đến các cuộc tấn công có thể đọc hoặc thay đổi các biến cục bộ
```
eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4
```
5 chậm hơn so với các giải pháp thay thế, vì nó phải gọi trình thông dịch JavaScript, trong khi nhiều cấu trúc khác được tối ưu hóa bởi các công cụ JS hiện đại
Trình thông dịch JavaScript hiện đại chuyển đổi JavaScript thành mã máy. Điều này có nghĩa là mọi khái niệm về cách đặt tên biến đều bị xóa sạch. Do đó, bất kỳ việc sử dụng
```
eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4
```
5 nào cũng sẽ buộc trình duyệt thực hiện tra cứu tên biến tốn kém dài để tìm ra vị trí tồn tại của biến trong mã máy và đặt giá trị của nó. Ngoài ra, những điều mới có thể được đưa vào biến đó thông qua
```
eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4
```
5, chẳng hạn như thay đổi loại biến đó, buộc trình duyệt phải đánh giá lại tất cả mã máy được tạo để bù lại
Công cụ khai thác từ bỏ bất kỳ hoạt động thu nhỏ nào nếu phạm vi phụ thuộc quá độ vào bởi ________ 85, vì nếu không thì ________ 85 không thể đọc đúng biến trong thời gian chạy

Có nhiều trường hợp việc sử dụng

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 hoặc các phương pháp liên quan có thể được tối ưu hóa hoặc tránh hoàn toàn

Sử dụng gián tiếp eval[]

Hãy xem xét mã này

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

Chỉ cần sử dụng eval gián tiếp và buộc chế độ nghiêm ngặt có thể làm cho mã tốt hơn nhiều

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

Hai đoạn mã trên dường như hoạt động theo cùng một cách, nhưng chúng thì không;

Nó chậm hơn rất nhiều, do kiểm tra phạm vi nhiều hơn. Lưu ý
```
    > var a = 12;
    > eval['a + 5']
    17
```
40 trong chuỗi được đánh giá. Trong phiên bản đánh giá gián tiếp, đối tượng đang được đánh giá trong phạm vi toàn cầu, do đó, trình thông dịch giả định rằng
```
    > var a = 12;
    > eval['a + 5']
    17
```
41 đề cập đến hàm tạo toàn cầu
```
    > var a = 12;
    > eval['a + 5']
    17
```
42 thay vì một biến cục bộ có tên là
```
    > var a = 12;
    > eval['a + 5']
    17
```
41. Tuy nhiên, trong mã sử dụng eval trực tiếp, trình thông dịch không thể giả sử điều này. Ví dụ: trong đoạn mã sau,
```
    > var a = 12;
    > eval['a + 5']
    17
```
41 trong chuỗi được đánh giá không đề cập đến
```
    > var a = 12;
    > eval['a + 5']
    17
```
45
```
    function [«param1», ..., «paramN»] {
        «funcBody»
    }
```
42
Do đó, trong phiên bản mã
```
eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4
```
5, trình duyệt buộc phải thực hiện cuộc gọi tra cứu tốn kém để kiểm tra xem liệu có bất kỳ biến cục bộ nào được gọi là
```
    > var a = 12;
    > eval['a + 5']
    17
```
42
Nếu không sử dụng chế độ nghiêm ngặt, các khai báo
```
    > var f = new Function['x', 'y', 'return x+y'];
    > f[3, 4]
    7
```
74 trong nguồn
```
eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4
```
5 sẽ trở thành các biến trong phạm vi xung quanh. Điều này dẫn đến các vấn đề khó gỡ lỗi nếu chuỗi được lấy từ đầu vào bên ngoài, đặc biệt nếu có một biến hiện có cùng tên
eval trực tiếp có thể đọc và biến đổi các liên kết trong phạm vi xung quanh, điều này có thể dẫn đến đầu vào bên ngoài làm hỏng dữ liệu cục bộ
Khi sử dụng
```
    new Function[param1, ..., paramN, funcBody]
```
67 trực tiếp, đặc biệt là khi nguồn eval không thể được chứng minh là ở chế độ nghiêm ngặt, công cụ — và công cụ xây dựng — phải vô hiệu hóa tất cả các tối ưu hóa liên quan đến nội tuyến, vì nguồn
```
eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4
```
5 có thể phụ thuộc vào bất kỳ tên biến nào trong phạm vi xung quanh của nó

Tuy nhiên, việc sử dụng

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 gián tiếp không cho phép chuyển các ràng buộc bổ sung ngoài các biến toàn cục hiện có để nguồn được đánh giá đọc. Nếu bạn cần chỉ định các biến bổ sung mà nguồn được đánh giá sẽ có quyền truy cập, hãy cân nhắc sử dụng hàm tạo

    > var a = 12;
    > eval['a + 5']
    17

Sử dụng hàm tạo Function[]

Hàm tạo

    > var a = 12;
    > eval['a + 5']
    17

83 rất giống với ví dụ gián tiếp eval ở trên. nó cũng đánh giá nguồn JavaScript được truyền cho nó trong phạm vi toàn cầu mà không cần đọc hoặc thay đổi bất kỳ ràng buộc cục bộ nào và do đó cho phép các công cụ thực hiện nhiều tối ưu hóa hơn so với

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 trực tiếp

Sự khác biệt giữa

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 và

    > var a = 12;
    > eval['a + 5']
    17

83 là chuỗi nguồn được chuyển đến

    > var a = 12;
    > eval['a + 5']
    17

83 được phân tích dưới dạng thân hàm, không phải dưới dạng tập lệnh. Có một số sắc thái — ví dụ: bạn có thể sử dụng các câu lệnh

    > var a = 12;
    > eval['a + 5']
    17

89 ở cấp cao nhất của thân hàm, nhưng không phải trong tập lệnh

Hàm tạo

    > var a = 12;
    > eval['a + 5']
    17

83 rất hữu ích nếu bạn muốn tạo các liên kết cục bộ trong nguồn eval của mình, bằng cách chuyển các biến dưới dạng các liên kết tham số

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

Cả

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 và

    > var a = 12;
    > eval['a + 5']
    17

83 đều đánh giá ngầm mã tùy ý và bị cấm trong cài đặt CSP nghiêm ngặt. Ngoài ra còn có bổ sung an toàn hơn [và nhanh hơn. ] các lựa chọn thay thế cho

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 hoặc

    > var a = 12;
    > eval['a + 5']
    17

83 cho các trường hợp sử dụng phổ biến

Sử dụng phụ kiện khung

Bạn không nên sử dụng

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 để truy cập các thuộc tính một cách linh hoạt. Xem xét ví dụ sau trong đó thuộc tính của đối tượng được truy cập không được biết cho đến khi mã được thực thi. Điều này có thể được thực hiện với

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

Tuy nhiên,

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 không cần thiết ở đây — trên thực tế, nó dễ bị lỗi hơn, bởi vì nếu

    > var a = 12;
    > eval['a + 5']
    17

28 không phải là mã định danh hợp lệ, nó sẽ dẫn đến lỗi cú pháp. Hơn nữa, nếu

    > var a = 12;
    > eval['a + 5']
    17

29 không phải là chức năng bạn kiểm soát, điều này có thể dẫn đến việc thực thi mã tùy ý. Thay vào đó, hãy sử dụng các trình truy cập thuộc tính, nhanh hơn và an toàn hơn nhiều

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

Bạn thậm chí có thể sử dụng phương pháp này để truy cập các thuộc tính hậu duệ. Sử dụng

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5, điều này sẽ giống như

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

Việc tránh

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 ở đây có thể được thực hiện bằng cách tách đường dẫn thuộc tính và lặp qua các thuộc tính khác nhau

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

Đặt thuộc tính theo cách đó hoạt động tương tự

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

Tuy nhiên, hãy lưu ý rằng việc sử dụng các bộ truy cập khung với đầu vào không bị ràng buộc cũng không an toàn — nó có thể dẫn đến các cuộc tấn công tiêm đối tượng

Sử dụng gọi lại

JavaScript có các hàm hạng nhất, nghĩa là bạn có thể chuyển các hàm làm đối số cho các API khác, lưu trữ chúng trong các biến và thuộc tính của đối tượng, v.v. Nhiều API DOM được thiết kế với ý tưởng này, vì vậy bạn có thể [và nên] viết

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

Các bao đóng cũng hữu ích như một cách để tạo các hàm được tham số hóa mà không cần nối các chuỗi

Sử dụng JSON

Nếu chuỗi bạn đang gọi

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 có chứa dữ liệu [ví dụ: một mảng.

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

403], trái ngược với mã, bạn nên cân nhắc chuyển sang JSON, điều này cho phép chuỗi sử dụng một tập hợp con cú pháp JavaScript để biểu thị dữ liệu

Lưu ý rằng vì cú pháp JSON bị giới hạn so với cú pháp JavaScript, nhiều chữ JavaScript hợp lệ sẽ không phân tích dưới dạng JSON. Ví dụ: không được phép sử dụng dấu phẩy ở cuối trong JSON và tên thuộc tính [khóa] trong ký tự đối tượng phải được đặt trong dấu ngoặc kép. Đảm bảo sử dụng trình nối tiếp JSON để tạo các chuỗi sau này sẽ được phân tích cú pháp dưới dạng JSON

Truyền dữ liệu bị ràng buộc cẩn thận thay vì mã tùy ý nói chung là một ý tưởng hay. Ví dụ: một tiện ích mở rộng được thiết kế để cạo nội dung của các trang web có thể có quy tắc cạo được xác định trong XPath thay vì mã JavaScript

Trong đoạn mã sau, cả hai câu lệnh chứa

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 đều trả về 42. Đầu tiên đánh giá chuỗi

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

405;

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 trả về giá trị hoàn thành của câu lệnh. Đối với

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

408, nó sẽ là biểu thức hoặc câu lệnh cuối cùng được đánh giá

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

Ví dụ sau sử dụng

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 để đánh giá chuỗi

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

410. Chuỗi này bao gồm các câu lệnh JavaScript gán giá trị 42 cho

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

411 nếu

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

412 là năm và gán 0 cho

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

411 nếu ngược lại. Khi câu lệnh thứ hai được thực thi,

eval[new String["2 + 2"]]; // returns a String object containing "2 + 2"
eval["2 + 2"]; // returns 4

5 sẽ khiến các câu lệnh này được thực hiện và nó cũng sẽ đánh giá tập hợp các câu lệnh và trả về giá trị được gán cho

    function [«param1», ..., «paramN»] {
        «funcBody»
    }

411, bởi vì giá trị hoàn thành của một phép gán là giá trị được gán

Tôi có thể sử dụng cái gì thay vì eval[] trong JavaScript?

Câu hỏi. Phương pháp 'eval' trong JavaScript/DemandwareScript không được dùng nữa dựa trên các rủi ro bảo mật tiềm ẩn khi sử dụng phương pháp này vì phương pháp này không thoát khỏi các tham số đầu vào. Câu trả lời. Thay vào đó, bạn nên sử dụng ' Hàm mới []'.

Sử dụng eval trong JavaScript có an toàn không?

KHÔNG sử dụng eval[] Thực thi JavaScript từ một chuỗi là một rủi ro bảo mật LỚN. Với eval[], mã độc có thể chạy bên trong ứng dụng của bạn mà không được phép. Với eval[], mã của bên thứ ba có thể thấy phạm vi ứng dụng của bạn, điều này có thể dẫn đến các cuộc tấn công có thể xảy ra.

Hàm JavaScript phổ biến nào bạn nên tránh eval?

Mã độc hại . gọi eval có thể làm hỏng máy tính. Ví dụ. nếu bạn sử dụng phía máy chủ eval và một người dùng tinh nghịch quyết định sử dụng một vòng lặp vô hạn làm tên người dùng của họ. chậm khủng khiếp. ngôn ngữ JavaScript được thiết kế để sử dụng đầy đủ các loại JavaScript [số, hàm, đối tượng, v.v.]… Không chỉ các chuỗi.

Làm cách nào để gọi một hàm JavaScript từ một chuỗi mà không cần sử dụng eval?

var params = "praveen. khoa học" // Bây giờ hãy gọi hàm mà không sử dụng eval. cửa sổ [fnName][params]; Điều này cũng có thể hữu ích để gọi các chức năng của Google Apps Script.