0 dants
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 adalah dua konsep yang relatif baru untuk deklarasi variabel dalam 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;
}
0 mirip dengants
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 dalam beberapa hal, tetapi memungkinkan pengguna untuk menghindari beberapa "gotcha" umum yang ditemui pengguna di JavaScriptts
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 adalah augmentasi darits
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 karena mencegah penugasan ulang ke variabelts
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;
}
Dengan TypeScript sebagai perpanjangan dari JavaScript, bahasa ini secara alami mendukung
0 dants
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. Di sini kami akan menguraikan lebih lanjut tentang deklarasi baru ini dan mengapa deklarasi tersebut lebih disukai daripadats
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;
}
3ts
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;
}
Jika Anda menggunakan JavaScript secara sembarangan, bagian selanjutnya mungkin merupakan cara yang baik untuk menyegarkan ingatan Anda. Jika Anda sangat akrab dengan semua keanehan deklarasi
3 dalam JavaScript, Anda mungkin akan lebih mudah untuk melewatinyats
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;
}
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 deklarasi
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; }
Mendeklarasikan variabel dalam JavaScript secara tradisional selalu dilakukan dengan kata kunci
3ts
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;
}
ts
var a = 10;
Seperti yang mungkin sudah Anda ketahui, kami baru saja mendeklarasikan variabel bernama
2 dengan nilaits
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
3ts
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
Kita juga dapat mendeklarasikan variabel di dalam suatu fungsi
ts
function f[] {
var message = "Hello, world!";
return message;
}
dan kami juga dapat mengakses variabel yang sama di dalam fungsi lain
ts
function f[] {
var a = 10;
return function g[] {
var b = a + 1;
return b;
};
}
var g = f[];
g[]; // returns '11'
Dalam contoh di atas,
_4 menangkap variabelts
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
2 yang dideklarasikan dalamts
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
6. Kapan punts
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
_4 dipanggil, nilaits
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
2 akan dikaitkan dengan nilaits
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
2 dits
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
6. Bahkan jikats
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
_4 dipanggil sekalits
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
6 selesai berjalan, itu akan dapat mengakses dan memodifikasits
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
2ts
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
ts
function f[] {
var a = 1;
a = 2;
var b = g[];
a = 3;
return b;
function g[] {
return a;
}
}
f[]; // returns '2'
Aturan pelingkupan
3 deklarasi memiliki beberapa aturan pelingkupan yang aneh untuk yang digunakan dalam bahasa lain. Ambil contoh berikutts
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;
}
ts
function f[shouldInitialize: boolean] {
if [shouldInitialize] {
var x = 10;
}
return x;
}
f[true]; // returns '10'
f[false]; // returns 'undefined'
Beberapa pembaca mungkin melakukan pengambilan ganda pada contoh ini. Variabel
_5 dideklarasikan di dalam blok
10 10 10 10 10 10 10 10 10 10
6, namun kami dapat mengaksesnya dari luar blok itu. Itu karena
10 10 10 10 10 10 10 10 10 10
3 deklarasi dapat diakses di mana saja di dalam fungsi, modul, namespace, atau cakupan globalnya - semua yang akan kita bahas nanti - terlepas dari blok yang memuatnya. Beberapa orang menyebutnyats
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-scoping atau function-scoping. Parameter juga merupakan cakupan fungsits
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;
}
Aturan pelingkupan ini dapat menyebabkan beberapa jenis kesalahan. Satu masalah yang mereka perburuk adalah fakta bahwa mendeklarasikan variabel yang sama beberapa kali bukanlah kesalahan
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;
}
Mungkin mudah dikenali oleh beberapa pengembang JavaScript yang berpengalaman, tetapi
9-loop bagian dalam akan secara tidak sengaja menimpa variabel
10 10 10 10 10 10 10 10 10 10
0 karena
0 1 2 3 4 5 6 7 8 9
0 merujuk ke variabel lingkup fungsi yang sama. Seperti yang diketahui pengembang berpengalaman sekarang, jenis bug serupa lolos dari tinjauan kode dan dapat menjadi sumber frustrasi yang tak ada habisnya
0 1 2 3 4 5 6 7 8 9
Kebiasaan menangkap variabel
Luangkan waktu sebentar untuk menebak hasil dari cuplikan berikut
ts
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
Bagi mereka yang tidak terbiasa,
2 akan mencoba menjalankan fungsi setelah beberapa milidetik [meskipun menunggu hal lain berhenti berjalan]
0 1 2 3 4 5 6 7 8 9
Siap?
10 10 10 10 10 10 10 10 10 10
Banyak pengembang JavaScript sangat akrab dengan perilaku ini, tetapi jika Anda terkejut, Anda pasti tidak sendirian. Kebanyakan orang mengharapkan hasilnya
0 1 2 3 4 5 6 7 8 9
Ingat apa yang kami sebutkan sebelumnya tentang pengambilan variabel?
Mari luangkan waktu sebentar untuk mempertimbangkan apa artinya itu.
2 akan menjalankan fungsi setelah beberapa milidetik, tetapi hanya setelah
0 1 2 3 4 5 6 7 8 9
9 berhenti mengeksekusi; . Jadi setiap kali fungsi yang diberikan dipanggil, itu akan mencetak
10 10 10 10 10 10 10 10 10 10
3ts
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
Solusi umum adalah menggunakan IIFE - Ekspresi Fungsi yang Segera Dipanggil - untuk menangkap
0 di setiap iterasi
0 1 2 3 4 5 6 7 8 9
ts
for [var i = 0; i < 10; i++] {
// capture the current state of 'i'
// by invoking a function with its current value
[function [i] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}][i];
}
Pola yang tampak aneh ini sebenarnya cukup umum.
0 dalam daftar parameter sebenarnya membayangi
0 1 2 3 4 5 6 7 8 9
0 yang dideklarasikan dalam
0 1 2 3 4 5 6 7 8 9
9 loop, tetapi karena kami menamakannya sama, kami tidak perlu terlalu banyak memodifikasi badan loop
10 10 10 10 10 10 10 10 10 10
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 deklarasi
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; }
Sekarang Anda telah mengetahui bahwa
3 memiliki beberapa masalah, itulah sebabnya pernyataants
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 diperkenalkan. Terlepas dari kata kunci yang digunakan,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 pernyataan ditulis dengan cara yang samats
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 pernyataan ditulis dengan cara yang samats
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;
}
0ts
function f[] {
var message = "Hello, world!";
return message;
}
Perbedaan utamanya bukan pada sintaksisnya, tetapi pada semantiknya, yang sekarang akan kita selami
Pelingkupan blok
Ketika sebuah variabel dideklarasikan menggunakan
0, ia menggunakan apa yang oleh beberapa orang disebut pelingkupan leksikal atau pelingkupan blok. Tidak seperti variabel yang dideklarasikan dengants
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 yang cakupannya bocor ke fungsi yang memuatnya, variabel dengan cakupan blok tidak terlihat di luar blok terdekatnya atauts
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-loop
10 10 10 10 10 10 10 10 10 10
1ts
function f[] {
var message = "Hello, world!";
return message;
}
Di sini, kami memiliki dua variabel lokal
2 dants
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
04. Cakupants
function f[] {
var message = "Hello, world!";
return message;
}
2 terbatas pada badants
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
6 sementara ruang lingkupts
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
04 terbatas pada blok pernyataants
function f[] {
var message = "Hello, world!";
return message;
}
6 yang mengandung
10 10 10 10 10 10 10 10 10 10
Variabel yang dideklarasikan dalam klausa
_09 juga memiliki aturan pelingkupan yang serupats
function f[] {
var message = "Hello, world!";
return message;
}
2ts
function f[] {
var message = "Hello, world!";
return message;
}
Properti lain dari variabel lingkup blok adalah bahwa mereka tidak dapat dibaca atau ditulis sebelum mereka benar-benar dideklarasikan. Sementara variabel-variabel ini "hadir" di seluruh cakupannya, semua poin hingga deklarasi mereka adalah bagian dari zona mati temporal mereka. Ini hanyalah cara canggih untuk mengatakan bahwa Anda tidak dapat mengaksesnya sebelum pernyataan
0, dan untungnya TypeScript akan memberi tahu Anda bahwats
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;
}
_3ts
function f[] {
var message = "Hello, world!";
return message;
}
Sesuatu yang perlu diperhatikan adalah bahwa Anda masih dapat menangkap variabel cakupan blok sebelum dideklarasikan. Satu-satunya tangkapan adalah ilegal memanggil fungsi itu sebelum deklarasi. Jika menargetkan ES2015, waktu proses modern akan menimbulkan kesalahan;
4ts
function f[] {
var message = "Hello, world!";
return message;
}
Untuk informasi lebih lanjut tentang zona mati sementara, lihat konten yang relevan di
Deklarasi ulang dan Membayangi
Dengan
3 deklarasi, kami menyebutkan bahwa tidak masalah berapa kali Anda mendeklarasikan variabel Anda;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;
}
5ts
function f[] {
var message = "Hello, world!";
return message;
}
Dalam contoh di atas, semua deklarasi
5 sebenarnya mengacu pada
10 10 10 10 10 10 10 10 10 10
5 yang sama, dan ini benar-benar valid. Ini sering berakhir menjadi sumber bug. Syukurlah, deklarasi
10 10 10 10 10 10 10 10 10 10
0 tidak memaafkants
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;
}
6ts
function f[] {
var message = "Hello, world!";
return message;
}
Variabel tidak perlu keduanya diblokir untuk TypeScript untuk memberi tahu kami bahwa ada masalah
7ts
function f[] {
var message = "Hello, world!";
return message;
}
Itu bukan untuk mengatakan bahwa variabel cakupan blok tidak pernah dapat dideklarasikan dengan variabel cakupan fungsi. Variabel cakupan blok hanya perlu dideklarasikan di dalam blok yang jelas berbeda
8ts
function f[] {
var message = "Hello, world!";
return message;
}
Tindakan memperkenalkan nama baru dalam lingkup yang lebih bersarang disebut membayangi. Ini adalah pedang bermata dua karena dapat memperkenalkan bug tertentu dengan sendirinya jika terjadi bayangan yang tidak disengaja, sekaligus mencegah bug tertentu. Misalnya, bayangkan kita telah menulis fungsi
15 kita sebelumnya menggunakants
function f[] {
var message = "Hello, world!";
return message;
}
0 variabelts
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;
}
_9ts
function f[] {
var message = "Hello, world!";
return message;
}
Versi loop ini benar-benar akan melakukan penjumlahan dengan benar karena
0 bayangan loop dalam
0 1 2 3 4 5 6 7 8 9
0 dari loop luar
0 1 2 3 4 5 6 7 8 9
Membayangi biasanya harus dihindari demi menulis kode yang lebih jelas. Meskipun ada beberapa skenario yang mungkin tepat untuk memanfaatkannya, Anda harus menggunakan penilaian terbaik Anda
Pengambilan variabel cakupan blok
Ketika kami pertama kali menyentuh gagasan menangkap variabel dengan deklarasi
3, kami secara singkat membahas bagaimana variabel bertindak setelah ditangkap. Untuk memberikan intuisi yang lebih baik tentang hal ini, setiap kali lingkup dijalankan, ia menciptakan "lingkungan" variabel. Lingkungan itu dan variabel yang ditangkapnya dapat tetap ada bahkan setelah segala sesuatu dalam cakupannya selesai dijalankants
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;
}
_0ts
function f[] {
var a = 10;
return function g[] {
var b = a + 1;
return b;
};
}
var g = f[];
g[]; // returns '11'
Karena kami telah menangkap
20 dari dalam lingkungannya, kami masih dapat mengaksesnya meskipun blokts
function f[] {
var message = "Hello, world!";
return message;
}
6 selesai dijalankan
10 10 10 10 10 10 10 10 10 10
Ingatlah bahwa dengan contoh
_2 kami sebelumnya, kami akhirnya perlu menggunakan IIFE untuk menangkap keadaan variabel untuk setiap iterasi dari
0 1 2 3 4 5 6 7 8 9
9 loop. Akibatnya, apa yang kami lakukan adalah membuat lingkungan variabel baru untuk variabel yang kami tangkap. Itu sedikit menyusahkan, tapi untungnya, Anda tidak perlu melakukannya lagi di TypeScript
10 10 10 10 10 10 10 10 10 10
0 deklarasi memiliki perilaku yang sangat berbeda ketika dideklarasikan sebagai bagian dari sebuah loop. Daripada hanya memperkenalkan lingkungan baru ke loop itu sendiri, deklarasi ini semacam membuat ruang lingkup baru per iterasi. Karena inilah yang kami lakukan dengan IIFE kami, kami dapat mengubah contohts
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 lama kami menjadi hanya menggunakan deklarasi
0 1 2 3 4 5 6 7 8 9
0ts
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;
}
_1ts
function f[] {
var a = 10;
return function g[] {
var b = a + 1;
return b;
};
}
var g = f[];
g[]; // returns '11'
dan seperti yang diharapkan, ini akan dicetak
0 1 2 3 4 5 6 7 8 9
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 deklarasi
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 deklarasi adalah cara lain untuk mendeklarasikan variabelts
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;
}
_3ts
function f[] {
var a = 10;
return function g[] {
var b = a + 1;
return b;
};
}
var g = f[];
g[]; // returns '11'
Mereka seperti
0 deklarasi tetapi, seperti namanya, nilainya tidak dapat diubah setelah mereka terikat. Dengan kata lain, mereka memiliki aturan pelingkupan yang sama dengants
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, tetapi Anda tidak dapat menetapkannya kembalits
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;
}
Ini tidak boleh dikacaukan dengan gagasan bahwa nilai yang mereka rujuk tidak dapat diubah
_4ts
function f[] {
var a = 10;
return function g[] {
var b = a + 1;
return b;
};
}
var g = f[];
g[]; // returns '11'
Kecuali jika Anda mengambil tindakan khusus untuk menghindarinya, keadaan internal variabel
1 masih dapat dimodifikasi. Untungnya, TypeScript memungkinkan Anda menentukan bahwa anggota suatu objek adalahts
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. Bab tentang Antarmuka memiliki detailnyats
function f[] {
var message = "Hello, world!";
return message;
}
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 vs. 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
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; }
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; }
Mengingat bahwa kami memiliki dua jenis deklarasi dengan semantik pelingkupan yang serupa, wajar jika kami bertanya mana yang akan digunakan. Seperti kebanyakan pertanyaan luas, jawabannya adalah. tergantung
Menerapkan prinsip hak istimewa terkecil, semua deklarasi selain yang Anda rencanakan untuk diubah harus menggunakan
1. Alasannya adalah jika sebuah variabel tidak perlu ditulis, orang lain yang bekerja pada basis kode yang sama seharusnya tidak secara otomatis dapat menulis ke objek, dan perlu mempertimbangkan apakah mereka benar-benar perlu menetapkan ulang ke variabel tersebut. Menggunakants
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 juga membuat kode lebih dapat diprediksi saat mempertimbangkan aliran datats
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;
}
Gunakan penilaian terbaik Anda, dan jika ada, konsultasikan masalah tersebut dengan anggota tim Anda yang lain
Sebagian besar buku pegangan ini menggunakan
0 deklarasits
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;
}
Merusak
Fitur ECMAScript 2015 lain yang dimiliki TypeScript adalah penghancuran struktur. Untuk referensi lengkap, lihat artikel di Mozilla Developer Network. Di bagian ini, kami akan memberikan ikhtisar singkat
Penghancuran susunan
Bentuk paling sederhana dari destrukturisasi adalah penugasan destrukturisasi array
_5ts
function f[] {
var a = 10;
return function g[] {
var b = a + 1;
return b;
};
}
var g = f[];
g[]; // returns '11'
Ini menciptakan dua variabel baru bernama
38 dants
function f[] {
var message = "Hello, world!";
return message;
}
39. Ini setara dengan menggunakan pengindeksan, tetapi jauh lebih nyamants
function f[] {
var message = "Hello, world!";
return message;
}
_6ts
function f[] {
var a = 10;
return function g[] {
var b = a + 1;
return b;
};
}
var g = f[];
g[]; // returns '11'
Destrukturisasi bekerja dengan variabel yang sudah dideklarasikan juga
_7ts
function f[] {
var a = 10;
return function g[] {
var b = a + 1;
return b;
};
}
var g = f[];
g[]; // returns '11'
Dan dengan parameter ke suatu fungsi
_8ts
function f[] {
var a = 10;
return function g[] {
var b = a + 1;
return b;
};
}
var g = f[];
g[]; // returns '11'
Anda dapat membuat variabel untuk sisa item dalam daftar menggunakan sintaks
40ts
function f[] {
var message = "Hello, world!";
return message;
}
_9ts
function f[] {
var a = 10;
return function g[] {
var b = a + 1;
return b;
};
}
var g = f[];
g[]; // returns '11'
Tentu saja, karena ini adalah JavaScript, Anda dapat mengabaikan elemen tambahan yang tidak Anda pedulikan
_0ts
function f[] {
var a = 1;
a = 2;
var b = g[];
a = 3;
return b;
function g[] {
return a;
}
}
f[]; // returns '2'
Atau elemen lainnya
_1ts
function f[] {
var a = 1;
a = 2;
var b = g[];
a = 3;
return b;
function g[] {
return a;
}
}
f[]; // returns '2'
Penghancuran tuple
Tuple dapat didestrukturisasi seperti array;
_2ts
function f[] {
var a = 1;
a = 2;
var b = g[];
a = 3;
return b;
function g[] {
return a;
}
}
f[]; // returns '2'
Merupakan kesalahan untuk merusak tuple di luar jangkauan elemennya
_3ts
function f[] {
var a = 1;
a = 2;
var b = g[];
a = 3;
return b;
function g[] {
return a;
}
}
f[]; // returns '2'
Seperti array, Anda dapat merusak sisa tuple dengan
40, untuk mendapatkan tuple yang lebih pendekts
function f[] {
var message = "Hello, world!";
return message;
}
_4ts
function f[] {
var a = 1;
a = 2;
var b = g[];
a = 3;
return b;
function g[] {
return a;
}
}
f[]; // returns '2'
Atau abaikan elemen trailing, atau elemen lainnya
_5ts
function f[] {
var a = 1;
a = 2;
var b = g[];
a = 3;
return b;
function g[] {
return a;
}
}
f[]; // returns '2'
Penghancuran objek
Anda juga dapat merusak objek
_6ts
function f[] {
var a = 1;
a = 2;
var b = g[];
a = 3;
return b;
function g[] {
return a;
}
}
f[]; // returns '2'
Ini menciptakan variabel baru
_2 dants
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
04 darits
function f[] {
var message = "Hello, world!";
return message;
}
44 dants
function f[] {
var message = "Hello, world!";
return message;
}
45. Perhatikan bahwa Anda dapat melewatits
function f[] {
var message = "Hello, world!";
return message;
}
_46 jika Anda tidak membutuhkannyats
function f[] {
var message = "Hello, world!";
return message;
}
Seperti penghancuran array, Anda dapat memiliki tugas tanpa deklarasi
_7ts
function f[] {
var a = 1;
a = 2;
var b = g[];
a = 3;
return b;
function g[] {
return a;
}
}
f[]; // returns '2'
Perhatikan bahwa kita harus mengapit pernyataan ini dengan tanda kurung. JavaScript biasanya mem-parsing
_47 sebagai awal blokts
function f[] {
var message = "Hello, world!";
return message;
}
Anda dapat membuat variabel untuk sisa item dalam objek menggunakan sintaks
40ts
function f[] {
var message = "Hello, world!";
return message;
}
_8ts
function f[] {
var a = 1;
a = 2;
var b = g[];
a = 3;
return b;
function g[] {
return a;
}
}
f[]; // returns '2'
Penggantian nama properti
Anda juga dapat memberikan nama yang berbeda untuk properti
_9ts
function f[] {
var a = 1;
a = 2;
var b = g[];
a = 3;
return b;
function g[] {
return a;
}
}
f[]; // returns '2'
Di sini sintaks mulai membingungkan. Anda dapat membaca
49 sebagai ”ts
function f[] {
var message = "Hello, world!";
return message;
}
2 sebagaits
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
51”. Arahnya dari kiri ke kanan, seolah-olah Anda telah menulists
function f[] {
var message = "Hello, world!";
return message;
}
0ts
function f[shouldInitialize: boolean] {
if [shouldInitialize] {
var x = 10;
}
return x;
}
f[true]; // returns '10'
f[false]; // returns 'undefined'
Yang membingungkan, titik dua di sini tidak menunjukkan jenisnya. Jenisnya, jika Anda menentukannya, masih perlu ditulis setelah seluruh penghancuran
1ts
function f[shouldInitialize: boolean] {
if [shouldInitialize] {
var x = 10;
}
return x;
}
f[true]; // returns '10'
f[false]; // returns 'undefined'
Nilai dasar
Nilai default memungkinkan Anda menentukan nilai default jika properti tidak ditentukan
2ts
function f[shouldInitialize: boolean] {
if [shouldInitialize] {
var x = 10;
}
return x;
}
f[true]; // returns '10'
f[false]; // returns 'undefined'
Dalam contoh ini
_52 menunjukkan bahwats
function f[] {
var message = "Hello, world!";
return message;
}
04 adalah opsional, jadi mungkints
function f[] {
var message = "Hello, world!";
return message;
}
54.ts
function f[] {
var message = "Hello, world!";
return message;
}
55 sekarang memiliki variabel untukts
function f[] {
var message = "Hello, world!";
return message;
}
56 serta propertits
function f[] {
var message = "Hello, world!";
return message;
}
2 dants
for [var i = 0; i < 10; i++] {
setTimeout[function [] {
console.log[i];
}, 100 * i];
}
04, bahkan jikats
function f[] {
var message = "Hello, world!";
return message;
}
04 tidak terdefinisits
function f[] {
var message = "Hello, world!";
return message;
}
Deklarasi fungsi
Destrukturisasi juga berfungsi dalam deklarasi fungsi. Untuk kasus sederhana, ini sangat mudah
3ts
function f[shouldInitialize: boolean] {
if [shouldInitialize] {
var x = 10;
}
return x;
}
f[true]; // returns '10'
f[false]; // returns 'undefined'
Tetapi menentukan default lebih umum untuk parameter, dan memperbaiki default dengan destrukturisasi bisa jadi rumit. Pertama-tama, Anda harus ingat untuk meletakkan pola sebelum nilai default
4ts
function f[shouldInitialize: boolean] {
if [shouldInitialize] {
var x = 10;
}
return x;
}
f[true]; // returns '10'
f[false]; // returns 'undefined'
Cuplikan di atas adalah contoh inferensi tipe, yang dijelaskan sebelumnya di buku pegangan
Kemudian, Anda harus ingat untuk memberikan default untuk properti opsional pada properti yang dirusak alih-alih penginisialisasi utama. Ingatlah bahwa
_60 didefinisikan dengants
function f[] {
var message = "Hello, world!";
return message;
}
04 opsionalts
function f[] {
var message = "Hello, world!";
return message;
}
5ts
function f[shouldInitialize: boolean] {
if [shouldInitialize] {
var x = 10;
}
return x;
}
f[true]; // returns '10'
f[false]; // returns 'undefined'
Gunakan penghancuran dengan hati-hati. Seperti yang ditunjukkan contoh sebelumnya, apa pun kecuali ekspresi penghancuran yang paling sederhana akan membingungkan. Hal ini terutama berlaku dengan perusakan bersarang yang sangat dalam, yang menjadi sangat sulit untuk dipahami bahkan tanpa menumpuk penggantian nama, nilai default, dan jenis anotasi. Cobalah untuk membuat ekspresi yang merusak tetap kecil dan sederhana. Anda selalu dapat menulis tugas yang akan dihasilkan oleh penghancuran sendiri
Menyebar
Operator spread adalah kebalikan dari destrukturisasi. Ini memungkinkan Anda untuk menyebarkan array ke array lain, atau objek ke objek lain. Sebagai contoh
6ts
function f[shouldInitialize: boolean] {
if [shouldInitialize] {
var x = 10;
}
return x;
}
f[true]; // returns '10'
f[false]; // returns 'undefined'
Ini memberi nilai bothPlus
_62. Menyebarkan membuat salinan dangkalts
function f[] {
var message = "Hello, world!";
return message;
}
_38 dants
function f[] {
var message = "Hello, world!";
return message;
}
39. Mereka tidak diubah oleh penyebarants
function f[] {
var message = "Hello, world!";
return message;
}
Anda juga dapat menyebarkan objek
7ts
function f[shouldInitialize: boolean] {
if [shouldInitialize] {
var x = 10;
}
return x;
}
f[true]; // returns '10'
f[false]; // returns 'undefined'
Sekarang
_65 adalahts
function f[] {
var message = "Hello, world!";
return message;
}
66. Penyebaran objek lebih kompleks daripada penyebaran array. Seperti penyebaran array, ia berjalan dari kiri ke kanan, tetapi hasilnya tetap berupa objek. Ini berarti properti yang datang belakangan di objek sebar akan menimpa properti yang datang lebih awal. Jadi jika kita memodifikasi contoh sebelumnya menjadi menyebar di bagian akhirts
function f[] {
var message = "Hello, world!";
return message;
}
8ts
function f[shouldInitialize: boolean] {
if [shouldInitialize] {
var x = 10;
}
return x;
}
f[true]; // returns '10'
f[false]; // returns 'undefined'
Kemudian properti
_67 dits
function f[] {
var message = "Hello, world!";
return message;
}
68 menimpats
function f[] {
var message = "Hello, world!";
return message;
}
69, yang bukan itu yang kita inginkan dalam kasus inits
function f[] {
var message = "Hello, world!";
return message;
}
Penyebaran objek juga memiliki beberapa batasan mengejutkan lainnya. Pertama, ini hanya mencakup properti milik objek yang dapat dihitung. Pada dasarnya, itu berarti Anda kehilangan metode saat menyebarkan instance objek
_9ts
function f[shouldInitialize: boolean] {
if [shouldInitialize] {
var x = 10;
}
return x;
}
f[true]; // returns '10'
f[false]; // returns 'undefined'
Kedua, kompiler TypeScript tidak mengizinkan penyebaran parameter tipe dari fungsi generik. Fitur itu diharapkan dalam versi bahasa yang akan datang