Technology sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

officium

Quodlibet munus exemplum est muneris genus, Function etiam proprietates et modos habet, sicut aliae species referuntur. Munera sunt objecta, et nomen functionis monstrator est functionis objecti, nec necessario arcte ad ipsum munus obligatur.

Functio definitio definitio functionis definitio

function sum (n1,n2){
return n1+n2;
}

Munus significatio functionis definitio

let sum = function(n1,n2){
return n1+n2;
};

munus definitionis munus

let sum = (n1,n2)=>{
return n1+n2;
};

munus definitionis conditor

let sum = new Function("n1","n2","return n1+n2");
/*这个构造函数接收任意多个字符串参数，
最后一个参数始终会被当成函数体，
而之前的参数都是新函数的参数*/

sagitta munus

Sagittae functiones alicubi adhiberi possunt expressio functionis adhiberi potest.

let sum = (a,b)=>{
return a+b;
};
let sum1 = function(a,b){
return a+b;
};
//箭头函数适合嵌入函数的场景
let arr = [1,2,3];
console.log(arr.map(function(i) {return i+1;}));
console.log(arr.map((i)=>{return i+1;}));
//二者结果一样，但是箭头函数更为简洁
 
//如果只有一个参数，括号可以不用。只有没有参数，或者多个参数的情况下，才使用括号
 
let double = (x)=>{return 2*x;};
let triple = x => {return 3*x};
 
//箭头函数也可以不使用大括号，但这样会改变函数的行为。使用大括号就说明包含函数体，可以在一
//个函数中包含多条语句，跟常规函数一样。如果不使用，后面只能有一行代码。
 
let double = (x)=>{return 2*x;};
let triple = x=>3*x;
 

Etsi sagittae functiones syntaxin simplicem habent, multae condiciones sunt ubi aptae non sunt. Sagittae functiones argumentis, super, new.targets uti nequeunt, neque pro conditoribus adhiberi possunt. Praeterea munera sagittae non habent prototypum attributum.

Mauris in sagittis munera

Munus definitur syntaxin sagittae utens, ideo parametri ad functionem accessi non possunt utens argumentorum keyword, sed solum per ambitum definitum nominatum accedere possunt.

function foo() { 
 console.log(arguments[0]); 
} 
foo(5); // 5 
let bar = () => { 
 console.log(arguments[0]); 
}; 
bar(5); // ReferenceError: arguments is not defined

Munus nomen

Munus plura nomina habere potest.

function sum(num1, num2) { 
 return num1 + num2; 
} 
console.log(sum(10, 10)); // 20 
let anotherSum = sum; 
console.log(anotherSum(10, 10)); // 20 
sum = null; 
console.log(anotherSum(10, 10)); // 20

Default parametri valorem

Valorem defaltam parametri assignare potes utendo = post modulum in functionis definitione.

function makeKing(name = 'Henry') { 
 return `King ${name} VIII`; 
} 
console.log(makeKing('Louis')); // 'King Louis VIII' 
console.log(makeKing()); // 'King Henry VIII'

Valores defaltae parametri non limitantur ad valores primitivos vel obiecti rationes, valores redditi a vocatione functionis adhiberi possunt.

let romanNumerals = ['I', 'II', 'III', 'IV', 'V', 'VI']; 
let ordinality = 0; 
function getNumerals() { 
 // 每次调用后递增
 return romanNumerals[ordinality++]; 
} 
function makeKing(name = 'Henry', numerals = getNumerals()) { 
 return `King ${name} ${numerals}`; 
} 
console.log(makeKing()); // 'King Henry I'
console.log(makeKing('Louis', 'XVI')); // 'King Louis XVI' 
console.log(makeKing()); // 'King Henry II' 
console.log(makeKing()); // 'King Henry III'

Parameter expansio et collectio

ES6 addit novam extensionem operator, quae adhiberi potest ad collectionem notitiarum collectionum perquam brevissime operandas et componendas. Utilissimus missionis ad divulgationem operantis est index parametri in definitione functionis, ubi plene uti potest debiles typinges et variae longitudinis parametri linguae. Prolixus operator uti potest parametros transire cum munus vocant, vel ambitum functionis definire.

Parametri extenso

let values = [1, 2, 3, 4]; 
function getSum() { 
 let sum = 0; 
 for (let i = 0; i < arguments.length; ++i) { 
 sum += arguments[i]; 
 } 
 return sum; 
} 
//不使用扩展操作符实现累加
console.log(getSum.apply(null,values));
 
//使用扩展操作符
console.log(getSum(...values));

Oratio parametri

Si parametri nominantur ante parametri collectos, reliqui tantum parametri colligentur; Quia effectus parametri colligendi variabilis est, tantum uti parametro ultimo adhiberi potest.

 
function getProduct(...values,lastValue){}//不可以
function ignoreFirst(firstValue,...values){console.log(values)}//可以
ignoreFirst(); // [] 
ignoreFirst(1); // [] 
ignoreFirst(1,2); // [2] 
ignoreFirst(1,2,3); // [2, 3]

Munus declaratio et munus expressio

Antequam codice aliquo exsecutioni mandatur, JavaScript engine legit declarationem functionis et definitio functionis in contextu exsecutionis generat. Munus expressionis exspectandum est donec signum ad lineam perficiatur antequam definitio functionis in contextu exsecutionis generatur.

// 没问题 
console.log(sum(10, 10)); 
function sum(num1, num2) { 
 return num1 + num2; 
}
/*函数声明提升*/
 
 
// 会出错
console.log(sum(10, 10)); 
let sum = function(num1, num2) { 
 return num1 + num2; 
};