Chuỗi có phải là một mảng ký tự trong javascript không?

Một điều tôi thích về Common Lisp là cách xử lý chung các chuỗi. (Thực ra, tôi ước nó tiến xa hơn với nó. ) Các chức năng không phụ thuộc vào các tính năng dành riêng cho danh sách thường hoạt động với bất kỳ loại trình tự nào. Ví dụ:

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

2 không chỉ hoạt động với danh sách, nó hoạt động trên bất kỳ trình tự nào

(remove-duplicates '(a b b c))  ; list
=> (A B C)

(remove-duplicates #(a b b c))  ; array
=> #(A B C)

Các chức năng như

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

3 và

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

4 yêu cầu danh sách vì hành vi của chúng sử dụng chúng một cách rõ ràng. Phiên bản trình tự chung của chúng là

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

0 và

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

1. Viết một hàm trình tự mới có nghĩa là bám vào các hàm trình tự chung này, đặc biệt là

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

2 và

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

3 thay vì các trình truy cập chuyên dụng hơn

Một chuỗi chỉ là một mảng một chiều — một vectơ — với các phần tử thuộc kiểu ký tự. Điều này có nghĩa là tất cả các hàm chuỗi cũng hoạt động trên chuỗi

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

Không có bộ hàm đặc biệt nào chỉ để thao tác trên chuỗi (ngoại trừ các hàm dành cho hoạt động dành riêng cho chuỗi). Các chuỗi mạnh mẽ và linh hoạt như bất kỳ chuỗi nào khác. Điều này rất thuận tiện

JavaScript

Thật không may, các chuỗi JavaScript không hoàn toàn là các mảng. Chúng trông và hoạt động hơi giống mảng, nhưng chúng thiếu một số phương thức hữu ích

var foo = "abcdef";

foo[1]
=> "b"

foo.length
=> 6

foo.reverse()  // error, no method 'reverse'

Lưu ý rằng, khi lập chỉ mục, nó trả về chuỗi một ký tự, không phải ký tự đơn. Điều này là do không có loại ký tự trong JavaScript. Sẽ rất thú vị nếu JavaScript đi theo con đường Elisp, nơi không có loại ký tự mà thay vào đó các ký tự được biểu thị bằng số nguyên, với một số loại ký tự bằng chữ để sử dụng các ký tự trong mã. Loại điều này có thể được mô phỏng bằng phương pháp

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

4

Để giải quyết vấn đề chuỗi không phải là mảng, các chuỗi có thể được chuyển đổi thành mảng bằng

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

5, được thao tác dưới dạng một mảng và được khôi phục bằng

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

6

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

0

Phương thức chuỗi

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

7 có thể đóng vai trò thay thế cho

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

1 và

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

9. Đối số thay thế có thể là một hàm, sẽ được gọi trong mỗi trận đấu. Nếu một ký tự tại một thời điểm được chọn để thay thế thì những gì còn lại là phương thức

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

1

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

5

Đối với

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

9, một chuỗi rỗng sẽ được trả về trong trường hợp vị từ trả về

var foo = "abcdef";

foo[1]
=> "b"

foo.length
=> 6

foo.reverse()  // error, no method 'reverse'

2 và kết quả khớp ban đầu trong trường hợp của

var foo = "abcdef";

foo[1]
=> "b"

foo.length
=> 6

foo.reverse()  // error, no method 'reverse'

3

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

9

Trong hầu hết các trường hợp, việc sử dụng các biểu thức chính quy thông thường sẽ đáp ứng nhu cầu về phương thức

var foo = "abcdef";

foo[1]
=> "b"

foo.length
=> 6

foo.reverse()  // error, no method 'reverse'

4, vì vậy điều này hầu như không cần thiết. Ví dụ, ở trên cũng có thể được thực hiện như vậy,

(make-array 10 :element-type 'character :initial-element #\a)
=> "aaaaaaaaaa"

(remove-duplicates "abbc")
=> "abc"

(map 'string #'char-upcase "foo")
=> "FOO"

(reverse "foo")
=> "oof"

1

Một cách khác để khắc phục các phương thức còn thiếu là chỉ cần triển khai các phương thức Array cho chuỗi và thêm chúng vào nguyên mẫu Chuỗi, nhưng điều đó thường được coi là cách làm không tốt

Là một chuỗi chỉ là một mảng của char?

Điều gì phân biệt một chuỗi từ một mảng char?