Rumah >hujung hadapan web >tutorial js >Soalan temuduga teknikal javascript yang paling mencabar dan paling sukar dengan penyelesaian.
Hello! Saya Vishal Tiwari dan saya akan memberikan anda beberapa soalan temuduga javascript yang mencabar.
console.log(typeof null); // Output?
Output: objek
Penjelasan: Ini adalah kebiasaan yang terkenal dalam JavaScript. Pengendali jenis mengembalikan "objek" apabila digunakan pada null, walaupun null bukan objek. Tingkah laku ini disebabkan oleh cara JavaScript dilaksanakan dan telah dikekalkan untuk keserasian ke belakang.
console.log(0.1 + 0.2 === 0.3); // Output?
Output: palsu
Penjelasan: Disebabkan cara aritmetik titik terapung berfungsi dalam JavaScript (dan banyak bahasa pengaturcaraan), 0.1 0.2 tidak sama dengan 0.3. Sebaliknya, ia menghasilkan 0.30000000000000004, yang membawa kepada perbandingan mengembalikan palsu.
const a = {}; const b = { key: 'b' }; const c = { key: 'c' }; a[b] = 123; // What happens here? console.log(a[b]); // Output?
Output: 123
Penjelasan: Apabila anda cuba menetapkan sifat pada objek menggunakan objek lain sebagai kunci (a[b]), JavaScript menukar objek b kepada rentetan, yang menghasilkan "[objek Objek ]". Oleh itu, anda pada dasarnya menetapkan sifat "[objek objek]" kepada 123 dan apabila anda log a[b], ia mengembalikan 123.
const arr = [1, 2, 3]; arr[10] = 11; console.log(arr.length); // Output?
Output: 11
Penjelasan: Apabila anda menetapkan nilai pada indeks yang lebih besar daripada panjang semasa tatasusunan (seperti arr[10] = 11), JavaScript mencipta "slot kosong" dalam tatasusunan untuk indeks dari 3 hingga 9. Walau bagaimanapun, sifat panjang tatasusunan mencerminkan indeks tertinggi tambah satu, yang dalam kes ini ialah 11.
let x = 1; let y = 2; const obj = { x: 10, y: 20, sum: function() { return this.x + this.y; } }; console.log(obj.sum()); // Output? console.log(obj.sum.call({ x: 100, y: 200 })); // Output? console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?
Output:
Penjelasan:
console.log(1 + '1'); // Output? console.log(1 - '1'); // Output?
Output:
Penjelasan:
console.log(typeof null); // Output?
Output: Output akan bergantung pada konteks di mana foo dipanggil, tetapi jika dalam konteks global, ia akan log objek global (tetingkap dalam penyemak imbas atau global dalam Node.js).
Penjelasan: Dalam fungsi anak panah, ini terikat secara leksikal, bermakna ia menggunakan nilai ini daripada konteks sekeliling. Jika foo dipanggil dalam skop global, ini akan merujuk kepada objek global.
console.log(0.1 + 0.2 === 0.3); // Output?
Output:
Penjelasan: Fungsi createCounter mencipta penutupan yang mengekalkan pembolehubah kiraannya sendiri. Setiap kaedah (kenaikan, pengurangan, getCount) mengakses dan mengubah suai pembolehubah kiraan yang sama, memberikan gelagat yang konsisten.
const a = {}; const b = { key: 'b' }; const c = { key: 'c' }; a[b] = 123; // What happens here? console.log(a[b]); // Output?
Output: [99, 2, 3]
Penjelasan: Dalam JavaScript, tatasusunan (seperti semua objek) ialah jenis rujukan. Apabila b ditugaskan kepada a, kedua-dua pembolehubah menghala ke tatasusunan yang sama dalam ingatan. Oleh itu, mengubah suai b mempengaruhi a.
const arr = [1, 2, 3]; arr[10] = 11; console.log(arr.length); // Output?
Output: 3
Penjelasan: Dalam contoh ini, fungsi dalam mempunyai pembolehubah sendiri, yang membayangi pembolehubah dalam fungsi luar. Apabila console.log(a) dipanggil dalam inner, ia merujuk kepada a yang ditakrifkan dalam inner, iaitu 3.
let x = 1; let y = 2; const obj = { x: 10, y: 20, sum: function() { return this.x + this.y; } }; console.log(obj.sum()); // Output? console.log(obj.sum.call({ x: 100, y: 200 })); // Output? console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?
Output: { a: 1, b: 3, c: 4 }
Penjelasan: Kaedah Object.assign() menyalin nilai semua sifat terhitung daripada satu atau lebih objek sumber (obj1 dan obj2) kepada objek sasaran (objek kosong {}). Jika sifat yang sama wujud dalam berbilang objek sumber, yang terakhir diutamakan. Oleh itu, b: 3 daripada obj2 menimpa b: 2 daripada obj1.
console.log(1 + '1'); // Output? console.log(1 - '1'); // Output?
Output: tidak ditentukan
Penjelasan: JavaScript secara automatik menyisipkan koma bertitik selepas penyataan kembali jika terdapat pemisah baris. Oleh itu, ia ditafsirkan sebagai pulangan;, yang mengembalikan tidak ditentukan. Untuk mengembalikan objek, anda harus meletakkan pendakap pembukaan { pada baris yang sama dengan kata kunci kembali.
console.log(typeof null); // Output?
Output: tidak ditentukan
Penjelasan: Pembolehubah x di dalam fungsi foo dinaikkan tetapi tidak dimulakan sehingga penugasan var x = 2;. Oleh itu, apabila console.log(x); dilaksanakan, x tempatan diisytiharkan tetapi belum ditetapkan, jadi ia menghasilkan tidak ditentukan.
console.log(0.1 + 0.2 === 0.3); // Output?
Output: 99
Penjelasan: Kedua-dua a dan b merujuk kepada tatasusunan yang sama dalam ingatan. Apabila anda mengubah suai b[0], anda turut mengubah suai a[0] kerana kedua-duanya merujuk tatasusunan yang sama.
const a = {}; const b = { key: 'b' }; const c = { key: 'c' }; a[b] = 123; // What happens here? console.log(a[b]); // Output?
Penjelasan:
const arr = [1, 2, 3]; arr[10] = 11; console.log(arr.length); // Output?
Output: []
Penjelasan: Menetapkan sifat panjang tatasusunan kepada 0 dengan berkesan mengosongkan tatasusunan. Oleh itu, arr kini merupakan tatasusunan kosong.
let x = 1; let y = 2; const obj = { x: 10, y: 20, sum: function() { return this.x + this.y; } }; console.log(obj.sum()); // Output? console.log(obj.sum.call({ x: 100, y: 200 })); // Output? console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?
Output: 2
Penjelasan: Fungsi dalam, apabila dipanggil, mempunyai pembolehubah sendiri iaitu 2. Apabila anda memanggil innerFunc(), ia log 2 kerana ia merujuk kepada pembolehubah tempatan a dalam dalam.
console.log(1 + '1'); // Output? console.log(1 - '1'); // Output?
Output: 3
Penjelasan: Kaedah c dipanggil pada obj, jadi di dalam kaedah ini merujuk kepada obj. Oleh itu, ia mengeluarkan hasil tambah obj.a dan obj.b, iaitu 3.
const foo = () => { console.log(this); }; foo(); // Output?
Penjelasan:
console.log(typeof null); // Output?
Output: objek global (atau tidak ditentukan dalam mod ketat)
Penjelasan: Dalam mod tidak ketat, nilai ini di dalam fungsi yang dipanggil dalam konteks global ialah objek global (iaitu, tetingkap dalam penyemak imbas atau global dalam Node.js). Dalam mod ketat, ini tidak akan ditentukan.
console.log(0.1 + 0.2 === 0.3); // Output?
Penjelasan:
const a = {}; const b = { key: 'b' }; const c = { key: 'c' }; a[b] = 123; // What happens here? console.log(a[b]); // Output?
Output: 3
Penjelasan: Dalam fungsi dalam, a merujuk kepada pembolehubah yang ditakrifkan di luar. Apabila inner dipanggil, a dinaikkan daripada 2 kepada 3 dan dilog.
const arr = [1, 2, 3]; arr[10] = 11; console.log(arr.length); // Output?
Output: Helo, nama saya tidak ditentukan
Penjelasan: Apabila salam dipanggil tanpa konteks (iaitu, bukan sebagai kaedah orang), ini tidak terikat kepada orang. Dalam mod tidak ketat, ini lalai kepada objek global, dan memandangkan nama tidak ditakrifkan pada objek global, ia log tidak ditentukan.
let x = 1; let y = 2; const obj = { x: 10, y: 20, sum: function() { return this.x + this.y; } }; console.log(obj.sum()); // Output? console.log(obj.sum.call({ x: 100, y: 200 })); // Output? console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?
Penjelasan:
console.log(1 + '1'); // Output? console.log(1 - '1'); // Output?
Penjelasan: Fungsi foo mengekalkan penutupan sekitar pembolehubah kiraan, yang dinaikkan setiap kali foo dipanggil, mengekalkan keadaannya merentas panggilan.
console.log(typeof null); // Output?
Output:
Penjelasan: a boleh diakses dalam fungsi kedua kerana penutupan. b juga boleh diakses seperti yang ditakrifkan pada mulanya. c ialah setempat kepada kedua, jadi ketiga-tiga pembolehubah dilog dengan betul.
console.log(0.1 + 0.2 === 0.3); // Output?
Output: 3
Penjelasan: Kaedah panggilan memanggil kenaikan dengan newObj seperti ini, jadi this.num merujuk kepada newObj.num. Operasi kenaikan menukar Obj.num baharu daripada 2 kepada 3.
const a = {}; const b = { key: 'b' }; const c = { key: 'c' }; a[b] = 123; // What happens here? console.log(a[b]); // Output?
Output:
const arr = [1, 2, 3]; arr[10] = 11; console.log(arr.length); // Output?
Penjelasan: Fungsi setTimeout semuanya merujuk pembolehubah i yang sama kerana pengangkatan. Apabila tamat masa dilaksanakan, i telah dinaikkan kepada 4, menyebabkan 4 dilog tiga kali.
let x = 1; let y = 2; const obj = { x: 10, y: 20, sum: function() { return this.x + this.y; } }; console.log(obj.sum()); // Output? console.log(obj.sum.call({ x: 100, y: 200 })); // Output? console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?
Penjelasan: Fungsi peta mencipta tatasusunan baharu berdasarkan transformasi yang digunakan pada setiap item. Tatasusunan asal kekal tidak berubah, manakala tatasusunan baru mencerminkan kenaikan.
console.log(1 + '1'); // Output? console.log(1 - '1'); // Output?
Output: Output akan bergantung pada konteks di mana foo dipanggil, tetapi jika dalam konteks global, ia akan log objek global (tetingkap dalam penyemak imbas atau global dalam Node.js).
Penjelasan: Dalam fungsi anak panah, ini terikat secara leksikal, bermakna ia menggunakan nilai ini daripada konteks sekeliling. Jika foo dipanggil dalam skop global, ini akan merujuk kepada objek global.
const foo = () => { console.log(this); }; foo(); // Output?
Output: 42
Penjelasan: Fungsi dalam ialah fungsi anak panah, yang secara leksikal mengikatnya dengan konteks fungsi kaedah. Oleh itu, this.value merujuk kepada obj.value, iaitu 42.
function createCounter() { let count = 0; return { increment: function() { count++; return count; }, decrement: function() { count--; return count; }, getCount: function() { return count; } }; } const counter = createCounter(); console.log(counter.increment()); // Output? console.log(counter.increment()); // Output? console.log(counter.getCount()); // Output? console.log(counter.decrement()); // Output? console.log(counter.getCount()); // Output?
Output: ReferenceError
Penjelasan: Pembolehubah x dinaikkan dalam myFunction, bermakna ia wujud dalam skop fungsi tetapi tidak dimulakan sehingga selepas console.log(x). Ini mengakibatkan ReferenceError kerana pembolehubah x diakses sebelum pengisytiharannya.
console.log(typeof null); // Output?
Output: Hello undefined
Penjelasan: Apabila salam dipanggil tanpa konteks yang jelas, ini tidak merujuk kepada obj, jadi this.name tidak ditentukan.
console.log(0.1 + 0.2 === 0.3); // Output?
Output: nombor
Penjelasan: Dalam JavaScript, NaN (Bukan-Nombor) dianggap sebagai jenis angka dan jenis NaN mengembalikan "nombor".
const a = {}; const b = { key: 'b' }; const c = { key: 'c' }; a[b] = 123; // What happens here? console.log(a[b]); // Output?
Output: [1, 2, 3, 4]
Penjelasan: Kedua-dua a dan b merujuk kepada tatasusunan yang sama dalam ingatan. Apabila anda menolak 4 ke dalam b, ia turut mempengaruhi a.
Atas ialah kandungan terperinci Soalan temuduga teknikal javascript yang paling mencabar dan paling sukar dengan penyelesaian.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!