search

Biến JavaScript nào không thể được khai báo?

1 năms trước
Trả lời: 0
Lượt xem: 191 

ts
  Show
  
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0 và 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
1 là hai khái niệm tương đối mới về khai báo biến trong JavaScript. Như chúng tôi đã đề cập trước đó, 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0 tương tự như 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
3 ở một số khía cạnh, nhưng cho phép người dùng tránh một số "sự cố" phổ biến mà người dùng gặp phải trong JavaScript

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
1 là phần mở rộng của 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0 ở chỗ nó ngăn việc gán lại cho một biến

Với TypeScript là một phần mở rộng của JavaScript, ngôn ngữ này tự nhiên hỗ trợ 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0 và 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
1. Ở đây chúng tôi sẽ giải thích thêm về những khai báo mới này và lý do tại sao chúng lại thích hợp hơn 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
3

Nếu bạn đã quen sử dụng JavaScript, phần tiếp theo có thể là một cách hay để bạn nhớ lại. Nếu bạn đã quen thuộc với tất cả những điều kỳ quặc của khai báo 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
3 trong JavaScript, thì bạn có thể thấy việc bỏ qua phía trước dễ dàng hơn

tsfunction sumMatrix(matrix: number[][]) { var sum = 0; for (var i = 0; i < matrix.length; i++) { var currentRow = matrix[i]; for (var i = 0; i < currentRow.length; i++) { sum += currentRow[i]; } } return sum;}3 tờ khai

Khai báo một biến trong JavaScript theo truyền thống luôn được thực hiện với từ khóa 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
3

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
2

Như bạn có thể đã hình dung ra, chúng ta vừa khai báo một biến tên là 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
32 với giá trị 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
33

Chúng ta cũng có thể khai báo một biến bên trong hàm

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
5

và chúng ta cũng có thể truy cập các biến tương tự trong các chức năng khác

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
6

Trong ví dụ trên, 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
34 đã bắt được biến 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
32 được khai báo trong 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
36. Tại bất kỳ thời điểm nào mà 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
34 được gọi, giá trị của 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
32 sẽ được gắn với giá trị của 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
32 trong 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
36. Ngay cả khi 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
34 được gọi sau khi 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
36 chạy xong, nó sẽ có thể truy cập và sửa đổi 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
32

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
7

quy tắc phạm vi

Khai báo 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
3 có một số quy tắc phạm vi kỳ lạ đối với những quy tắc được sử dụng cho các ngôn ngữ khác. Lấy ví dụ sau

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
9

Một số độc giả có thể thực hiện gấp đôi ví dụ này. Biến 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
05 đã được khai báo trong khối 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
06, nhưng chúng tôi vẫn có thể truy cập nó từ bên ngoài khối đó. Đó là bởi vì các khai báo 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
3 có thể truy cập được ở bất kỳ đâu trong hàm chứa, mô-đun, không gian tên hoặc phạm vi toàn cầu - tất cả những gì chúng ta sẽ xem xét sau - bất kể khối chứa là gì. Một số người gọi đây là phạm vi 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
3 hoặc phạm vi chức năng. Các tham số cũng nằm trong phạm vi chức năng

Các quy tắc phạm vi này có thể gây ra một số loại lỗi. Một vấn đề mà chúng làm trầm trọng thêm là việc khai báo cùng một biến nhiều lần không phải là lỗi

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}

Có thể dễ dàng phát hiện ra đối với một số nhà phát triển JavaScript có kinh nghiệm, nhưng vòng lặp 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
09 bên trong sẽ vô tình ghi đè lên biến 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
60 vì 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
60 đề cập đến cùng một biến trong phạm vi chức năng. Như các nhà phát triển có kinh nghiệm đã biết, các loại lỗi tương tự sẽ lọt qua các bài đánh giá mã và có thể là nguồn gây thất vọng vô tận.

Quirks chụp biến

Hãy nhanh chóng đoán xem đầu ra của đoạn mã sau là gì

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
3

Đối với những người không quen thuộc, 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
62 sẽ cố gắng thực thi một chức năng sau một số mili giây nhất định (mặc dù phải đợi mọi thứ khác ngừng chạy)

Sẳn sàng? 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0

Nhiều nhà phát triển JavaScript rất quen thuộc với hành vi này, nhưng nếu bạn thấy ngạc nhiên, thì chắc chắn bạn không đơn độc. Hầu hết mọi người mong đợi đầu ra là

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
6

Hãy nhớ những gì chúng tôi đã đề cập trước đó về chụp biến?

Hãy dành một phút để xem xét điều đó có nghĩa là gì. 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
62 sẽ chạy một chức năng sau một số mili giây, nhưng chỉ sau khi vòng lặp 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
09 đã ngừng thực thi; . Vì vậy, mỗi khi hàm đã cho được gọi, nó sẽ in ra 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
33

Một công việc phổ biến xung quanh là sử dụng IIFE - Biểu thức hàm được gọi ngay lập tức - để ghi lại 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
60 tại mỗi lần lặp

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
1

Mô hình trông kỳ lạ này thực sự khá phổ biến. 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
60 trong danh sách tham số thực sự che khuất 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
60 được khai báo trong vòng lặp 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
09, nhưng vì chúng tôi đặt tên chúng giống nhau nên chúng tôi không phải sửa đổi thân vòng lặp quá nhiều

tsfunction sumMatrix(matrix: number[][]) { var sum = 0; for (var i = 0; i < matrix.length; i++) { var currentRow = matrix[i]; for (var i = 0; i < currentRow.length; i++) { sum += currentRow[i]; } } return sum;}0 tờ khai

Bây giờ bạn đã phát hiện ra rằng 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
3 có một số vấn đề, đó chính là lý do tại sao câu lệnh 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0 được giới thiệu. Ngoài từ khóa được sử dụng, câu lệnh 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0 được viết giống như cách viết câu lệnh 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
3

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
50

Sự khác biệt chính không nằm ở cú pháp, mà ở ngữ nghĩa, mà bây giờ chúng ta sẽ đi sâu vào

phạm vi khối

Khi một biến được khai báo bằng cách sử dụng 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0, nó sẽ sử dụng cái mà một số người gọi là phạm vi từ vựng hoặc phạm vi khối. Không giống như các biến được khai báo với 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
3 có phạm vi rò rỉ ra hàm chứa của chúng, các biến có phạm vi khối không hiển thị bên ngoài khối chứa gần nhất của chúng hoặc vòng lặp 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
09

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
51

Ở đây, chúng ta có hai biến cục bộ 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
32 và 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
504. Phạm vi của 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
32 được giới hạn trong phần thân của 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
36 trong khi phạm vi của 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
504 được giới hạn trong khối chứa câu lệnh 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
06

Các biến được khai báo trong mệnh đề 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
509 cũng có các quy tắc xác định phạm vi tương tự

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
52

Một thuộc tính khác của các biến trong phạm vi khối là chúng không thể được đọc hoặc ghi trước khi chúng thực sự được khai báo. Mặc dù các biến này “hiện diện” trong phạm vi của chúng, nhưng tất cả các điểm cho đến khi khai báo của chúng là một phần của vùng chết tạm thời của chúng. Đây chỉ là một cách phức tạp để nói rằng bạn không thể truy cập chúng trước câu lệnh 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0 và may mắn là TypeScript sẽ cho bạn biết điều đó

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
53

Một điều cần lưu ý là bạn vẫn có thể nắm bắt một biến trong phạm vi khối trước khi nó được khai báo. Vấn đề duy nhất là việc gọi hàm đó trước khi khai báo là bất hợp pháp. Nếu nhắm mục tiêu ES2015, thời gian chạy hiện đại sẽ gây ra lỗi; 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
54

Để biết thêm thông tin về các vùng chết tạm thời, hãy xem nội dung liên quan trên Mozilla Developer Network

Khai báo lại và Shadowing

Với khai báo 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
3, chúng tôi đã đề cập rằng việc bạn khai báo biến bao nhiêu lần không quan trọng; 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
55

Trong ví dụ trên, tất cả các khai báo của 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
05 thực sự đề cập đến cùng một 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
05 và điều này hoàn toàn hợp lệ. Điều này thường kết thúc là một nguồn lỗi. Rất may, khai báo 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0 không dễ tha thứ

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
56

Các biến không nhất thiết phải nằm trong phạm vi khối để TypeScript cho chúng tôi biết rằng có sự cố

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
57

Điều đó không có nghĩa là một biến trong phạm vi khối không bao giờ có thể được khai báo bằng một biến trong phạm vi chức năng. Biến phạm vi khối chỉ cần được khai báo trong một khối khác biệt rõ ràng

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
58

Hành động giới thiệu một tên mới trong một phạm vi lồng nhau hơn được gọi là tạo bóng. Đó là một con dao hai lưỡi ở chỗ nó có thể tự giới thiệu một số lỗi nhất định trong trường hợp vô tình bị che khuất, đồng thời ngăn chặn một số lỗi nhất định. Chẳng hạn, hãy tưởng tượng chúng ta đã viết hàm 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
515 trước đó bằng cách sử dụng biến 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
59

Phiên bản này của vòng lặp sẽ thực sự thực hiện phép tính tổng một cách chính xác vì 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
60 của vòng lặp bên trong đổ bóng 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
60 từ vòng lặp bên ngoài

Shadowing thường nên tránh để viết mã rõ ràng hơn. Mặc dù có một số tình huống có thể phù hợp để tận dụng lợi thế của nó, nhưng bạn nên sử dụng phán đoán tốt nhất của mình

Chụp biến trong phạm vi khối

Khi chúng tôi lần đầu tiên chạm vào ý tưởng thu thập biến bằng khai báo 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
3, chúng tôi đã tìm hiểu sơ qua về cách các biến hoạt động sau khi được thu thập. Để hiểu rõ hơn về điều này, mỗi khi một phạm vi được chạy, nó sẽ tạo ra một “môi trường” của các biến. Môi trường đó và các biến bị bắt của nó có thể tồn tại ngay cả sau khi mọi thứ trong phạm vi của nó đã thực thi xong

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
60

Bởi vì chúng ta đã chiếm được 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
520 từ bên trong môi trường của nó, nên chúng ta vẫn có thể truy cập nó mặc dù thực tế là khối 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
06 đã thực thi xong

Nhớ lại rằng với ví dụ 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
62 trước đó của chúng tôi, cuối cùng chúng tôi cần sử dụng IIFE để nắm bắt trạng thái của một biến cho mỗi lần lặp của vòng lặp 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
09. Trên thực tế, những gì chúng tôi đang làm là tạo một môi trường biến mới cho các biến đã chụp của chúng tôi. Đó là một chút khó khăn, nhưng may mắn thay, bạn sẽ không bao giờ phải làm điều đó một lần nữa trong TypeScript

Khai báo 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0 có hành vi khác hẳn khi được khai báo như một phần của vòng lặp. Thay vì chỉ giới thiệu một môi trường mới cho chính vòng lặp, các khai báo này sẽ tạo ra một phạm vi mới cho mỗi lần lặp lại. Vì đây là những gì chúng tôi đang làm với IIFE của mình, chúng tôi có thể thay đổi ví dụ 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
62 cũ của mình để chỉ sử dụng khai báo 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
61

và như mong đợi, điều này sẽ in ra

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
6

tsfunction sumMatrix(matrix: number[][]) { var sum = 0; for (var i = 0; i < matrix.length; i++) { var currentRow = matrix[i]; for (var i = 0; i < currentRow.length; i++) { sum += currentRow[i]; } } return sum;}1 tờ khai

Khai báo 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
1 là một cách khác để khai báo biến

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
63

Chúng giống như các khai báo 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0, nhưng như tên gọi của chúng, giá trị của chúng không thể thay đổi một khi chúng bị ràng buộc. Nói cách khác, chúng có cùng quy tắc phạm vi như 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0, nhưng bạn không thể gán lại cho chúng

Không nên nhầm lẫn điều này với ý tưởng rằng các giá trị mà chúng đề cập đến là bất biến

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
64

Trừ khi bạn thực hiện các biện pháp cụ thể để tránh nó, trạng thái bên trong của biến 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
1 vẫn có thể sửa đổi được. May mắn thay, TypeScript cho phép bạn chỉ định rằng các thành viên của một đối tượng là 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
532. Chương về Giao diện có các chi tiết

tsfunction sumMatrix(matrix: number[][]) { var sum = 0; for (var i = 0; i < matrix.length; i++) { var currentRow = matrix[i]; for (var i = 0; i < currentRow.length; i++) { sum += currentRow[i]; } } return sum;}0 so với. tsfunction sumMatrix(matrix: number[][]) { var sum = 0; for (var i = 0; i < matrix.length; i++) { var currentRow = matrix[i]; for (var i = 0; i < currentRow.length; i++) { sum += currentRow[i]; } } return sum;}1

Cho rằng chúng tôi có hai loại khai báo với ngữ nghĩa phạm vi tương tự nhau, thật tự nhiên khi chúng tôi hỏi nên sử dụng loại nào. Giống như hầu hết các câu hỏi rộng, câu trả lời là. nó phụ thuộc

Áp dụng nguyên tắc đặc quyền tối thiểu, tất cả các khai báo khác với những gì bạn định sửa đổi nên sử dụng 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
1. Cơ sở lý luận là nếu một biến không cần phải ghi vào, thì những biến khác làm việc trên cùng một cơ sở mã sẽ không thể tự động ghi vào đối tượng và sẽ cần xem xét liệu chúng có thực sự cần gán lại cho biến đó hay không. Sử dụng 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
1 cũng làm cho mã dễ đoán hơn khi lập luận về luồng dữ liệu

Sử dụng phán đoán tốt nhất của bạn và nếu có thể, hãy tham khảo vấn đề với những người còn lại trong nhóm của bạn

Phần lớn sổ tay này sử dụng các tờ khai 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
0

hủy diệt

Một tính năng khác của ECMAScript 2015 mà TypeScript có là phá hủy. Để có tài liệu tham khảo đầy đủ, hãy xem bài viết trên Mozilla Developer Network. Trong phần này, chúng tôi sẽ cung cấp một cái nhìn tổng quan ngắn

Phá hủy mảng

Hình thức phá hủy đơn giản nhất là phép gán phá hủy mảng

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
65

Điều này tạo ra hai biến mới có tên là 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
538 và 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
539. Điều này tương đương với việc sử dụng lập chỉ mục, nhưng tiện lợi hơn nhiều

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
66

Việc hủy cấu trúc cũng hoạt động với các biến đã được khai báo

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
67

Và với các tham số cho một chức năng

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
68

Bạn có thể tạo một biến cho các mục còn lại trong danh sách bằng cú pháp 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
540

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
69

Tất nhiên, vì đây là JavaScript, nên bạn có thể bỏ qua các phần tử ở cuối mà bạn không quan tâm

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
70

Hoặc các yếu tố khác

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
71

Tuple phá hủy

Các bộ dữ liệu có thể bị phá hủy giống như các mảng; 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
72

Có lỗi khi hủy cấu trúc một bộ ngoài phạm vi các phần tử của nó

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
73

Như với mảng, bạn có thể hủy cấu trúc phần còn lại của bộ dữ liệu bằng 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
540, để có bộ dữ liệu ngắn hơn

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
74

Hoặc bỏ qua các phần tử theo sau hoặc các phần tử khác

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
75

phá hủy đối tượng

Bạn cũng có thể hủy cấu trúc các đối tượng

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
76

Điều này tạo ra các biến mới 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
32 và 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
504 từ 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
544 và 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
545. Lưu ý rằng bạn có thể bỏ qua 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
546 nếu không cần

Giống như hủy mảng, bạn có thể gán mà không cần khai báo

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
77

Lưu ý rằng chúng ta phải bao quanh tuyên bố này bằng dấu ngoặc đơn. JavaScript thường phân tích cú pháp 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
547 khi bắt đầu khối

Bạn có thể tạo một biến cho các mục còn lại trong một đối tượng bằng cú pháp 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
540

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
78

đổi tên tài sản

Bạn cũng có thể đặt tên khác cho thuộc tính

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
79

Ở đây cú pháp bắt đầu trở nên khó hiểu. Bạn có thể đọc 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
549 thành ”
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
32 thành 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
551”. Hướng từ trái sang phải, như thể bạn đã viết

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
90

Thật khó hiểu, dấu hai chấm ở đây không chỉ ra loại. Loại, nếu bạn chỉ định, vẫn cần được viết sau khi hủy toàn bộ

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
91

Giá trị mặc định

Giá trị mặc định cho phép bạn chỉ định giá trị mặc định trong trường hợp thuộc tính không được xác định

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
92

Trong ví dụ này, 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
552 chỉ ra rằng 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
504 là tùy chọn, vì vậy có thể là 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
554. 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
555 hiện có một biến cho 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
556 cũng như các thuộc tính 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
32 và 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
504, ngay cả khi 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
504 không được xác định

khai báo hàm

Việc hủy cấu trúc cũng hoạt động trong khai báo hàm. Đối với các trường hợp đơn giản, điều này là đơn giản

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
93

Nhưng việc chỉ định các giá trị mặc định phổ biến hơn đối với các tham số và việc xác định đúng các giá trị mặc định bằng cách hủy có thể khó khăn. Trước hết, bạn cần nhớ đặt mẫu trước giá trị mặc định

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
94

Đoạn mã trên là một ví dụ về suy luận kiểu, đã được giải thích trước đó trong sổ tay

Sau đó, bạn cần nhớ đặt mặc định cho các thuộc tính tùy chọn trên thuộc tính bị hủy cấu trúc thay vì trình khởi tạo chính. Hãy nhớ rằng 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
560 được xác định với tùy chọn 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
504

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
95

Sử dụng phá hủy một cách cẩn thận. Như ví dụ trước cho thấy, bất cứ điều gì ngoại trừ biểu thức phá hủy đơn giản nhất đều khó hiểu. Điều này đặc biệt đúng với việc phá hủy được lồng sâu, điều này thực sự khó hiểu ngay cả khi không chồng chất đổi tên, giá trị mặc định và chú thích loại. Cố gắng giữ cho các biểu thức phá hủy nhỏ và đơn giản. Bạn luôn có thể viết các bài tập mà việc phá hủy sẽ tự tạo ra

Lây lan

Toán tử trải rộng ngược lại với phá hủy. Nó cho phép bạn trải một mảng thành một mảng khác hoặc một đối tượng thành một đối tượng khác. Ví dụ

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
96

Điều này mang lại cho bothPlus giá trị 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
562. Trải rộng tạo ra một bản sao nông của 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
538 và 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
539. Chúng không bị thay đổi bởi sự lây lan

Bạn cũng có thể lây lan các đối tượng

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
97

Bây giờ 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
565 là 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
566. Trải rộng đối tượng phức tạp hơn trải rộng mảng. Giống như mảng trải rộng, nó tiến hành từ trái sang phải, nhưng kết quả vẫn là một đối tượng. Điều này có nghĩa là các thuộc tính xuất hiện sau trong đối tượng trải rộng sẽ ghi đè lên các thuộc tính xuất hiện trước đó. Vì vậy, nếu chúng ta sửa đổi ví dụ trước để trải rộng ở cuối

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
98

Sau đó, thuộc tính 

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
567 trong 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
568 ghi đè lên 
ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
569, đây không phải là điều chúng tôi muốn trong trường hợp này

Trải rộng đối tượng cũng có một vài giới hạn đáng ngạc nhiên khác. Đầu tiên, nó chỉ bao gồm các thuộc tính vô số của riêng một đối tượng. Về cơ bản, điều đó có nghĩa là bạn mất các phương thức khi trải rộng các thể hiện của một đối tượng

ts
function sumMatrix(matrix: number[][]) {
  var sum = 0;
  for (var i = 0; i < matrix.length; i++) {
    var currentRow = matrix[i];
    for (var i = 0; i < currentRow.length; i++) {
      sum += currentRow[i];
    }
  }
  return sum;
}
99

Thứ hai, trình biên dịch TypeScript không cho phép trải rộng các tham số kiểu từ các hàm chung. Tính năng đó được mong đợi trong các phiên bản tương lai của ngôn ngữ

Biến JavaScript nào không được khai báo?

Bạn không thể khai báo một biến trùng lặp bằng cách sử dụng từ khóa let có cùng tên và viết thường. JavaScript sẽ đưa ra một lỗi cú pháp. Mặc dù, các biến có thể có cùng tên nếu được khai báo bằng từ khóa var (đây là lý do tại sao nên sử dụng let ).

Từ khóa nào Không thể được sử dụng để khai báo một biến trong JavaScript?

Chúng tôi không thể sử dụng bất kỳ từ khóa dành riêng nào ( function, return, typeof, break , v.v. ) của Javascript dưới dạng tên biến.

Có bao nhiêu loại chúng ta có thể khai báo biến trong JavaScript?

JavaScript có ba kiểu khai báo biến. Khai báo một biến, tùy ý khởi tạo nó thành một giá trị.

Không thể là một tên biến trong JavaScript?

Tên biến không được là từ khóa . Ví dụ: từ 'let' được coi là từ khóa trong JavaScript. Do đó, bạn không thể định nghĩa một biến gọi là 'let'. Đoạn mã sau dẫn đến lỗi.

programming javascript

Bài Viết Liên Quan

Lỗi thoát python
Lỗi thoát python

MySQL nơi đếm lớn hơn
MySQL nơi đếm lớn hơn

Xóa dấu phẩy khỏi chuỗi công thức Excel
Xóa dấu phẩy khỏi chuỗi công thức Excel

Bộ nhớ được lưu trữ như thế nào trong Python?
Bộ nhớ được lưu trữ như thế nào trong Python?

Stdin stdout và stderr trong Python là gì?
Stdin stdout và stderr trong Python là gì?

Bạn sẽ điều hướng giữa nhiều trang trong html như thế nào?
Bạn sẽ điều hướng giữa nhiều trang trong html như thế nào?

Nhật ký bàn làm việc mysql
Nhật ký bàn làm việc mysql

Làm cách nào để đếm danh sách trong python 3?
Làm cách nào để đếm danh sách trong python 3?

Chế độ xem web trong html
Chế độ xem web trong html

Dòng mới trong truy vấn MySQL SELECT
Dòng mới trong truy vấn MySQL SELECT

MỚI CẬP NHẬP

Ngữ văn 6 viết bài tập làm văn số 2 năm 2024
10 phúts trước . bởi OverturnedWaitress
23 điểm khối b nên chọn trường nào 2023 năm 2024
34 phúts trước . bởi DeclaredHeads
Sổ phụ ngân hàng tiếng anh là gì năm 2024
46 phúts trước . bởi FussyHandshake
Lỗi cf file is changed w 2007 l o năm 2024
1 giờs trước . bởi AspiringCollision
Mệnh và thân cái nào quan trọng hơn năm 2024
1 giờs trước . bởi WideningMagnificence
Nguyên nhân dẫn đèn tai nạn giao thông là gì năm 2024
1 giờs trước . bởi UngratefulBarrier
Ôn tập toán học kì 2 lớp 10 năm 2024
1 giờs trước . bởi CoerciveAccuracy
Xiaomi redmi note 5 pro lỗi khi update android 9 năm 2024
1 giờs trước . bởi IncompleteScenery
Nền kinh tế đang chuyển đổi tiếng anh là gì năm 2024
2 giờs trước . bởi SpecificNationality
Các nước việt nam nhập khẩu hàng hóa năm 2024
2 giờs trước . bởi PropheticIndecency

Xem Nhiều

Yeu tố nước trong kiến trúc cảnh quan là gì năm 2024
1 tuầns trước . bởi PreservingWiring
File kẹp tài liệu đục lỗ tiếng anh là gì năm 2024
1 ngàys trước . bởi InsidiousReceptor
Lỗi khi mở folder màn hình view bị thu nhỏ năm 2024
3 ngàys trước . bởi RegimentalAdoption
Viết bài văn nghị luận về bảo vệ môi trường năm 2024
1 ngàys trước . bởi RaspingPatchwork
Công văn sở giáo dục đào tạo tỉnh quảng ngãi năm 2024
11 giờs trước . bởi DapperFoothold
Uống vitamin d vào lúc nào tốt nhất năm 2024
2 ngàys trước . bởi PrimordialHacker
Rách giời rơi xuống nghĩa là gì năm 2024
4 ngàys trước . bởi VastOrientation
Lỗi không gõ được tiếng việt trên amis năm 2024
7 giờs trước . bởi PonderousCivility
Chính sách kế hoạch hóa gia đình 2023 năm 2024
1 tuầns trước . bởi FinancialAllotment
Những bài toán lớp 1 giúp trẻ tư duy năm 2024
1 ngàys trước . bởi AnnoyedWomanhood

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

Bản quyền © 2024 Inc.