Penjelasan terperinci tentang cara fungsi JavaScript melaksanakan parameter pembolehubah? (Perkongsian ringkasan)

JS ialah bahasa yang ditaip lemah dan tidak boleh menggunakan kata kunci param untuk mengisytiharkan bahawa parameter formal ialah parameter pembolehubah seperti C#. Jadi bagaimana untuk melaksanakan parameter pembolehubah ini dalam js? Artikel berikut akan membincangkan kaedah pelaksanaan parameter pembolehubah fungsi JavaScript. Saya harap ia akan membantu semua orang!

Pelaksanaan parameter pembolehubah JS 1: argumen

Apakah itu argumen? Bagaimana untuk melaksanakan parameter pembolehubah?

argumen ialah objek seperti tatasusunan yang sepadan dengan hujah yang dihantar kepada fungsi.

Dalam ES5, anda boleh menggunakan objek argumen untuk melaksanakan parameter pembolehubah.

Panjang objek argumen ditentukan oleh bilangan parameter sebenar dan bukannya bilangan parameter formal. Parameter formal ialah pembolehubah yang dibuka semula dalam ruang memori dalam fungsi, tetapi ia tidak bertindih dengan ruang memori objek argumen. Apabila kedua-dua hujah dan nilai wujud, kedua-dua nilai itu disegerakkan, tetapi apabila salah satu daripadanya tidak mempunyai nilai, nilai itu tidak akan disegerakkan untuk kes tidak bernilai ini.

<script>
function dynamicArgs() {
	var info = "今日签到的学生有：";
	for (let i = 0; i < arguments.length ; i ++) {
		if (i > 0) {
			info += ",";
		}
		info += arguments[i];
	}
	
	console.log(info);
}

dynamicArgs("张三", "李四");
dynamicArgs("张三", "李四", "王五", "马六");
dynamicArgs(["张三", "李四", "王五", "马六", "jack", "rose"]);
</script>

• Parameter tidak pasti, jadi jangan tuliskannya.

• Anda boleh menulis N berbilang parameter semasa memanggil, atau anda boleh menghantar tatasusunan secara terus.

Kesan pelaksanaan:

Ringkasan:

1 definisi , jika anda menggunakan argumen parameter pembolehubah dalam fungsi, anda tidak perlu menulis parameter formal

2. Apabila memanggil fungsi, anda boleh terus menghantar berbilang parameter sebenar

argumen objek kepada fungsi adalah pembolehubah tempatan yang tersedia dalam semua fungsi (bukan anak panah). Anda boleh menggunakan objek argumen untuk merujuk argumen fungsi dalam fungsi. Objek ini mengandungi setiap parameter yang dihantar ke fungsi, dengan parameter pertama pada indeks 0. Sebagai contoh, jika fungsi diluluskan tiga parameter, anda boleh merujuknya seperti ini:

arguments[0]
arguments[1]
arguments[2]

Parameter juga boleh ditetapkan:

arguments[0] = 'value';

arguments 是一个对象， bukan Array. Ia serupa dengan Array tetapi tidak mempunyai sebarang atribut Array kecuali atribut panjang dan elemen indeks. Sebagai contoh, ia tidak mempunyai kaedah pop. Tetapi ia boleh ditukar kepada Array sebenar:

jadi anda sering boleh melihat kod seperti ini:

// 由于arguments不是 Array，所以无法使用 Array 的方法，所以通过这种方法转换为数组
 
var args = [].slice.call(arguments);  // 方式一
var args = Array.prototype.slice.call(arguments); // 方式二
 
// 下面是 es6 提供的语法
let args = Array.from(arguments)   // 方式一
let args = [...arguments]; // 方式二

argumen Atribut pada <span style="font-size: 16px;">上的属性</span>

• arguments.callee: menunjuk kepada fungsi yang sedang dilaksanakan (dalam mod ketat, ECMAScript versi 5 (ES5a<strong>rguments.callee()</strong>) Penggunaan dilarang a
rguments.callee()
• )
• argunments.length: menunjuk kepada bilangan argumen yang dihantar ke fungsi semasa

argumen .pemanggil: Dialih keluar

argumen yang digabungkan dengan baki parameter, parameter lalai dan parameter tugasan yang musnah

arguments

1) dalam mod ketat , kewujudan baki parameter, parameter lalai dan parameter tugasan yang dimusnahkan tidak akan mengubah tingkah laku objek

function func(a) { 
  arguments[0] = 99;   // 更新了arguments[0] 同样更新了a
  console.log(a);
}
func(10); // 99

// 并且

function func(a) { 
  a = 99;              // 更新了a 同样更新了arguments[0] 
  console.log(arguments[0]);
}
func(10); // 99

, tetapi ia berbeza dalam mod tidak ketat

2) Apabila ia tidak ketat Jika fungsi arguments dalam corak tidak mengandungi parameter baki, parameter lalai dan penetapan penstrukturan, maka nilai dalam objek

akan

function func(a = 55) { 
  arguments[0] = 99; // updating arguments[0] does not also update a
  console.log(a);
}
func(10); // 10

//

function func(a = 55) { 
  a = 99; // updating a does not also update arguments[0]
  console.log(arguments[0]);
}
func(10); // 10


function func(a = 55) { 
  console.log(arguments[0]);
}
func(); // undefined

menjejaki nilai parameter (dan sebaliknya ). Lihat kod berikut:

Pelaksanaan 2 parameter pembolehubah JS: parameter rehat (...)

…变量名

telah diperkenalkan dalam standard ES6 Parameter selebihnya (dalam bentuk

) digunakan untuk mendapatkan parameter berlebihan fungsi. Pembolehubah yang dipadankan dengan parameter selebihnya ialah tatasusunan, yang meletakkan parameter berlebihan ke dalam tatasusunan. Sangat sesuai untuk menangani parameter panjang berubah-ubah.

Rehat adalah untuk menyelesaikan masalah ketidakkonsistenan dalam bilangan parameter yang diluluskan. Ini bermakna menerima parameter tambahan dan meletakkannya ke dalam tatasusunan itu sendiri ialah tatasusunan, dan semua kaedah berkaitan tatasusunan boleh digunakan.

Sintaks pelaksanaan parameter pembolehubah:

function f(a, b, ...theArgs) {
  // ...
}

theArgs bermula dengan "...", ia adalah tatasusunan, nilainya datang daripada pemanggil sebenar yang menghantar [0,theArgs.length) (julat indeks: 0 hingga theArgs.length-1)

Nota

:

function f(arg1, ...rest, arg2) { // arg2 after ...rest ?!
  // error
}

Tidak boleh ada sebarang parameter lain selepas parameter selebihnya (iaitu, ia hanya boleh menjadi parameter terakhir), jika tidak, ralat akan dilaporkan.

Bezakan antara parameter rehat dan objek parameter (argumen)

parameter rehat tidak akan be Setiap pembolehubah diberi nama yang berasingan, dan objek parameter mengandungi semua parameter yang dihantar ke fungsi
Objek parameter bukan tatasusunan sebenar, dan parameter selebihnya ialah tatasusunan sebenar contoh. Contohnya, kaedah isihan tatasusunan, peta, forEach dan pop boleh digunakan secara langsung

• Objek parameter mempunyai ciri tambahannya sendiri (seperti atribut callee)

Rest参数的引入减少样式代码

//以前函数
function f(a, b) {
  var args = Array.prototype.slice.call(arguments, f.length);
 
  // …
}
 
// 等效于现在
 
function f(a, b, ...args) {
  
}

Rest参数可以被解构（通俗一点，将rest参数的数据解析后一一对应）不要忘记参数用[] 括起来，因为它数组嘛

function f(...[a, b, c]) {
  return a + b + c;
}
 
f(1)          //NaN 因为只传递一个值，其实需要三个值
f(1, 2, 3)    // 6
f(1, 2, 3, 4) // 6 (第四值没有与之对应的变量名)

示例

1、计算参数和

function sumAll(...args) { // args 是数组的名称
  let sum = 0;
 
  for (let arg of args) sum += arg;
 
  return sum;
}
 
console.log( sumAll(1) ); // 1
console.log( sumAll(1, 2) ); // 3
console.log( sumAll(1, 2, 3) ); // 6

2、每个参数乘以2

function multiply(multiplier, ...theArgs) {
  return theArgs.map(function(element) {
    return multiplier * element;
  });
}
 
var arr = multiply(2, 1, 2, 3); 
console.log(arr); // [2, 4, 6]

3、排序

function sortRestArgs(...theArgs) {
  var sortedArgs = theArgs.sort();
  return sortedArgs;
}
//好像一位和两位混合不能进行排序，这需要看一下为甚？主要第一个为主
console.log(sortRestArgs(5, 3, 7, 1)); // shows 1, 3, 5, 7

对比：参数对象arguments不能排序

function sortArguments() {
  //arguments是参数对象不能直接使用sort()方法，因为不是数组实例，需要转换
  var sortedArgs = arguments.sort(); 
  return sortedArgs; // this will never happen
}
 
// 会抛出类型异常，arguments.sort不是函数
console.log(sortArguments(5, 3, 7, 1));

【相关推荐：javascript学习教程 、编程视频】

Atas ialah kandungan terperinci Penjelasan terperinci tentang cara fungsi JavaScript melaksanakan parameter pembolehubah? (Perkongsian ringkasan). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!