AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

JavaScript专项算法题（3）：闭包

2023-01-10 86
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 闭包、作用域和运行上下文挑战1 createFunction问题:构建createFunction函数，用于创建和返回函数。当被创建的函数被调用时，它会打印“hello”。题解：1234567891011// CHALLENGE 1function createFunction() { const innerFunction = () => { console.log("hello"); } return innerFunction;}/*** Uncomment these to check your work! ***/co

闭包、作用域和运行上下文

挑战1 createFunction

问题:

构建createFunction函数，用于创建和返回函数。当被创建的函数被调用时，它会打印“hello”。

题解：

1
2
3
4
5
6
7
8
9
10
11
 
// CHALLENGE 1
functioncreateFunction() {
const innerFunction = () => {
console.log("hello");
  }
return innerFunction;
}
/*** Uncomment these to check your work! ***/
const function1 = createFunction();
function1(); // => should console.log('hello');

挑战2 createFunctionPrinter

问题：

构建接受一个输入值作为参数的createFunctionPrinter函数，用于创建和返回一个特定函数。当特定函数被调用时，其应该打印特定函数被创建时输入createFunctionPrinter中的值。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
// CHALLENGE 2
functioncreateFunctionPrinter(input) {
const innerValue = input;
const innerFunction = () => {
console.log(innerValue);
  }
return innerFunction;
}
/*** Uncomment these to check your work! ***/
const printSample = createFunctionPrinter('sample');
printSample(); // => should console.log('sample');
const printHello = createFunctionPrinter('hello');
printHello(); // => should console.log('hello');

挑战3 addByX

问题：

观察下面outer函数的实现代码。注意其会返回一个函数而且那个函数使用了不在其作用域的变量。尝试推断一下运行outer函数得到的输出值，然后构建addByX函数，其会返回一个接受一个输入值作为参数并与x相加的函数。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
// CHALLENGE 3
functionouter() {
let counter = 0; // this variable is outside incrementCounter's scope
functionincrementCounter () {
    counter ++;
console.log('counter', counter);
  }
return incrementCounter;
}
const willCounter = outer();
const jasCounter = outer();
// Uncomment each of these lines one by one.
// Before your do, guess what will be logged from each function call.
/*** Uncomment these to check your work! ***/
willCounter();
willCounter();
willCounter();
jasCounter();
willCounter();
functionaddByX(x) {
let backpackValue = x ;
const innerFunction = (el) => {
return backpackValue + el;
  }
return innerFunction;
}
/*** Uncomment these to check your work! ***/
const addByTwo = addByX(2);
console.log(addByTwo(1)); // => should return 3
console.log(addByTwo(2)); // => should return 4
console.log(addByTwo(3)); // => should return 5
const addByThree = addByX(3);
console.log(addByThree(1)); // => should return 4
console.log(addByThree(2)); // => should return 5
const addByFour = addByX(4);
console.log(addByFour(4)); // => should return 8
console.log(addByFour(5)); // => should return 9

挑战4 once

问题：

构建once函数，接受参数为一个回调函数并返回一个特定函数。当特定函数被第一次调用时，其会调用回调函数并返回输出值。如果其不是被第一次调用，则特定函数仅仅返回第一次调用时得到的回调函数返回值，而不是再次运行回调函数。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
// CHALLENGE 4
functiononce(func) {
let counter = 0;
let innerValue = 0; 
const innerFunction = (el) => {
    counter++;
if(counter == 1) {
      innerValue = func(el);
return innerValue;
    } else {
return innerValue;
    }
  }
return innerFunction;
}
/*** Uncomment these to check your work! ***/
const onceFunc = once(addByTwo);
console.log(onceFunc(4));  // => should log 6
console.log(onceFunc(10));  // => should log 6
console.log(onceFunc(9001));  // => should log 6

挑战5 after

问题：

构建after函数，接受一个数字n和一个回调函数作为参数。回调函数需要在通过after构建的函数运行第n次时才被运行。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
// CHALLENGE 5
functionafter(count, func) {
let counter = count;
const innerFunction = () => {
    counter--;
if(counter == 0){
      func();
    }
  }
return innerFunction;
}
/*** Uncomment these to check your work! ***/
const called = function() { console.log('hello') };
const afterCalled = after(3, called);
afterCalled(); // => nothing is printed
afterCalled(); // => nothing is printed
afterCalled(); // => 'hello' is printed

挑战6 delay

问题：

构建delay函数，接受一个回调函数作为第一个参数，一个数值n（单位为毫秒）作为第二个参数。delay函数被调用后，须经n毫秒后才运行回调函数。任何其他赋给特定函数的参数会在n毫秒后被回调函数使用。提示：研究setTimeout();

题解：

1
2
3
4
5
6
 
// CHALLENGE 6
functiondelay(func, wait, ...args) {
  setTimeout(() => func(...args), wait);
}
delay(called, 2000);  // "hello" after 2 seconds.

挑战7 rollCall

问题：

构建rollCall函数，接受一个由名字组成的数组，返回一个特定函数。第一次调用特定函数时，其会打印数组的第一个名字。第二次调用时，打印第二个名字，一直下去，直到所有名字都被打印。当所有名字都被打印后，其会打印“Everyone accounted for”。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
// CHALLENGE 7
functionrollCall(names) {
const innerArray = newArray;
for(let i=0; i<names.length; i++){
    innerArray[i] = names[i];
  }
const innerFunction = () => {
if(innerArray.length == 0){
console.log("Everyone accounted for");
    } else {
console.log(innerArray.shift());
    }
  }
return innerFunction;
}
/*** Uncomment these to check your work! ***/
const rollCaller = rollCall(['Victoria', 'Juan', 'Ruth'])
rollCaller() // => should log 'Victoria'
rollCaller() // => should log 'Juan'
rollCaller() // => should log 'Ruth'
rollCaller() // => should log 'Everyone accounted for'

挑战8 saveOutput

问题：

构建saveOutput函数，接受一个回调函数（其接受一个参数）和一个字符串（充当密码）作为参数。saveOutput会返回一个特定函数，其作用与回调函数类似，只是当它的字符串参数与saveOutput函数的密码字符串参数相同时，特定函数会利用先前所有调用特定函数时的输入值作为对象的键，对应回调函数的输出值作为值，构建一个对象，并返回之。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
// CHALLENGE 8
functionsaveOutput(func, magicWord) {
const storedMagicWord = magicWord;
const storedInputArray = newArray;
const storedOutputArray = newArray;
const exitObject = newObject;
let tempOutput = 0;
const innerFunction = (el) => {
if(el !== storedMagicWord) {
      storedInputArray.push(el);
      tempOutput = func(el);
      storedOutputArray.push(tempOutput);
return tempOutput;
    } else {
if(storedInputArray.length == storedOutputArray.length) {
for(let i=0; i<storedInputArray.length; i++){
    exitObject[storedInputArray[i]]=storedOutputArray[i];
        }
return exitObject;
      } else{
return'error';
      }
    }
  }
return innerFunction;
}
/*** Uncomment these to check your work! ***/
const multiplyBy2 = function(num) { return num * 2; };
const multBy2AndLog = saveOutput(multiplyBy2, 'boo');
console.log(multBy2AndLog(2)); // => should log 4
console.log(multBy2AndLog(9)); // => should log 18
console.log(multBy2AndLog('boo')); // => should log { 2: 4, 9: 18 }

挑战9 cycleIterator

问题：

构建cycleIterator函数，接受参数为一个数组并返回一个特定函数。特定函数不接受参数。当第一次调用时，特定函数返回数组的第一个元素。第二次调用时，返回第二个元素，一直下去。当特定函数已返回数组的最后一个元素后，下一次调用此特定函数时其返回数组的第一个元素，然后第二个元素，一直下去。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
// CHALLENGE 9
functioncycleIterator(array) {
let counter = 0;
const innerFunction = () => {
		counter++;
if(counter > array.length){
      counter = 0;
return array[counter];
    } else{
return array[counter-1];
    }
  }
return innerFunction;
}
/*** Uncomment these to check your work! ***/
const threeDayWeekend = ['Fri', 'Sat', 'Sun'];
const getDay = cycleIterator(threeDayWeekend);
console.log(getDay()); // => should log 'Fri'
console.log(getDay()); // => should log 'Sat'
console.log(getDay()); // => should log 'Sun'
console.log(getDay()); // => should log 'Fri'

挑战10 defineFirstArg

问题：

构建defineFirstArg函数，接受参数为一个回调函数和一个数值。回调函数接受至少一个参数。defineFirstArg会返回一个特定函数。此特定函数会将defineFirstArg的数值参数作为回调函数的第一个参数，输入到特定函数的参数作为回调函数的第二个参数，并调用回调函数。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
 
// CHALLENGE 10
functiondefineFirstArg(func, arg) {
const innerFunction = (el) =>{
return func(arg, el);
  }
return innerFunction;
}
/*** Uncomment these to check your work! ***/
const subtract = function(big, small) { return big - small; };
const subFrom20 = defineFirstArg(subtract, 20);
console.log(subFrom20(5)); // => should log 15

挑战11 dateStamp

问题：

构建dateStamp函数，接受参数为一个回调函数并返回一个特定函数。特定函数会接受回调函数所需要的参数并传给回调函数，返回一个对象记录特定函数被调用时的日期信息（date键）以及回调函数的输出（output键）。提示：你可能需要研究一下如何获取Date对象中的信息。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
// CHALLENGE 11
functiondateStamp(func) {
let dateInfo;
const innerObj = newObject;
const innerFunction = (el) => {
    dateInfo = newDate();
    innerObj['date'] = dateInfo.toString();
    innerObj['output'] = func(el);
return innerObj;
  }
return innerFunction;
}
/*** Uncomment these to check your work! ***/
const stampedMultBy2 = dateStamp(n => n * 2);
console.log(stampedMultBy2(4)); // => should log { date: (today's date), output: 8 }
console.log(stampedMultBy2(6)); // => should log { date: (today's date), output: 12 }

挑战12 censor

问题：

构建censor函数，不接受参数。censor会返回一个接受两个字符串或单个字符串参数的特定函数。当得到两个字符串参数时，特定函数会存储两个字符串作为一对，以备后续使用。当得到一个字符串参数时，特定函数会返回同样的字符串，只是此字符串中与存储字符串对的第一个字符串相同的字符串会被替换成存储字符串对中的第二个字符串。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
// CHALLENGE 12
functioncensor() {
let parameterInfoObj = newObject;
let oneParameterArray = newArray;
let punctuationArray = newArray;
const innerFunc = (el1, el2) => {
if(el1 && el2) {
      oneParameterArray = [];
      punctuationArray = [];
      parameterInfoObj[el1] = el2;
return parameterInfoObj;
    }
elseif(el1 && !el2){
      oneParameterArray = el1.match(/\b(\w+)\b/g);
      punctuationArray = el1.match(/([,. ]+)/g);
for(let i = 0; i<oneParameterArray.length; i++){
for(let key in parameterInfoObj){
if(key === oneParameterArray[i]){
            oneParameterArray[i] = parameterInfoObj[key];
          }
        }
      }
for(let i =0; i<oneParameterArray.length; i++){
        oneParameterArray[i] += punctuationArray[i]; 
      }
return oneParameterArray.join("");
    }
  }
return innerFunc;
}
/*** Uncomment these to check your work! ***/
const changeScene = censor();
changeScene('dogs', 'cats');
changeScene('quick', 'slow');
console.log(changeScene('The quick, brown fox jumps over the lazy dogs.')); // => should log 'The slow, brown fox jumps over the lazy cats.'

挑战13 createSecretHolder

问题：

JavaScript对象中并没有私有属性的定义，然而或许可以自定义一个？构建createSecretHolder(secret)函数，接受任何值作为secret参数，并且仅返回两个方法，返回secret值的getSecret()和设置secret值的setSecret()。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
// CHALLENGE 13
functioncreateSecretHolder(secret) {
let secretInfo = secret;
const innerObj = newObject;
  innerObj.getSecret = ()=>{
return secretInfo;
  }
  innerObj.setSecret = (el)=>{
    secretInfo = el;
  }
return innerObj;
}
/*** Uncomment these to check your work! ***/
const obj = createSecretHolder(5)
console.log(obj.getSecret()) // => returns 5
console.log(obj.setSecret(2)) // => undefined
console.log(obj.getSecret()) // => returns 2

挑战14 callTimes

问题：

构建callTimes函数，返回一个特定函数。特定函数应返回它被调用的次数信息。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
// CHALLENGE 14
functioncallTimes() {
let counter = 0;
const innerFunction = () => {
return ++counter;
  }
return innerFunction;
}
/*** Uncomment these to check your work! ***/
let myNewFunc1 = callTimes();
let myNewFunc2 = callTimes();
console.log(myNewFunc1()); // => 1
console.log(myNewFunc1()); // => 2
console.log(myNewFunc2()); // => 1
console.log(myNewFunc2()); // => 2

挑战15 russianRoulette

问题：

构建russianRoulette函数，作用为接受一个数值参数（假设为n）并返回一个特定函数。此特定函数不接受输入参数，而且会在前n-1次调用时返回字符串“click“，在第n次调用时则返回字符串”bang“，n次以后再调用皆返回字符串”reload to play again”。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
// CHALLENGE 15
functionrussianRoulette(num) {
let counter = num;
const innerFunction = () => {
      counter--;
if(counter>0) {
return"click";
      } elseif(counter==0){
return"bang";
      } else{
return"reload to play again";
      }
    }
return innerFunction; 
}
/*** Uncomment these to check your work! ***/
const play = russianRoulette(3);
console.log(play()); // => should log 'click'
console.log(play()); // => should log 'click'
console.log(play()); // => should log 'bang'
console.log(play()); // => should log 'reload to play again'
console.log(play()); // => should log 'reload to play again'

挑战16 average

问题：

构建average函数，不接受参数，并返回一个特定函数（接受一个数值作为参数或无参数）。当average创建的特定函数被输入数值参数的方式调用时，返回值为所有曾经被输入到特定函数的数值参数的平均值（重复数值视为分别的数值）。当特定函数被无参数的方式调用时，返回当前的平均值。如果特定函数在无参数方式调用时不曾被输入数值参数的方式调用过，则返回0。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
// CHALLENGE 16
functionaverage() {
let averageValue = 0;
let argumentCounter = 0;
let argumentSum = 0;
const innerFunction = (el) => {
if(el == undefined) {
return averageValue;
      } else{
        argumentCounter++;
        argumentSum += el; 
        averageValue = argumentSum / argumentCounter;
return averageValue;
      }
    }
return innerFunction;
}
/*** Uncomment these to check your work! ***/
const avgSoFar = average();
console.log(avgSoFar()); // => should log 0
console.log(avgSoFar(4)); // => should log 4
console.log(avgSoFar(8)); // => should log 6
console.log(avgSoFar()); // => should log 6
console.log(avgSoFar(12)); // => should log 8
console.log(avgSoFar()); // => should log 8

挑战17 makeFuncTester

问题：

构建makeFuncTester函数，接受参数为一个二维数组（其中第二维数组仅含两个元素），返回一个接收回调函数作为参数的特定函数。当二维数组的每一个子数组的第一个元素输入到回调函数时都产生与第二个元素相同的返回值时，特定函数返回ture，否则特定函数返回false。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
// CHALLENGE 17
functionmakeFuncTester(arrOfTests) {
const firstLayerArray = [];
for(let i = 0; i<arrOfTests.length; i++){
let secondLayerArray = [];
for(let j = 0; j<arrOfTests[i].length; j++){
      secondLayerArray.push(arrOfTests[i][j]);
    }
    firstLayerArray.push(secondLayerArray);
  }
const innerFunction = (callback) => {
for(let i=0; i<firstLayerArray.length; i++){
if(callback(firstLayerArray[i][0]) !== firstLayerArray[i][1]){
returnfalse;
      }
    }
returntrue;
  }
return innerFunction;
}
/*** Uncomment these to check your work! ***/
const capLastTestCases = [];
capLastTestCases.push(['hello', 'hellO']);
capLastTestCases.push(['goodbye', 'goodbyE']);
capLastTestCases.push(['howdy', 'howdY']);
const shouldCapitalizeLast = makeFuncTester(capLastTestCases);
const capLastAttempt1 = str => str.toUpperCase();
const capLastAttempt2 = str => str.slice(0, -1) + str.slice(-1).toUpperCase();
console.log(shouldCapitalizeLast(capLastAttempt1)); // => should log false
console.log(shouldCapitalizeLast(capLastAttempt2)); // => should log true

挑战18 makeHistory

问题：

构建makeHistory函数，接受一个数值参数n（充当限定值）并返回一个特定函数（接受字符串作为参数）。特定函数会存储限定个数为n的最近输入到此特定函数中的字符串参数历史（每次调用存储一次）。每次一个字符串被输入到特定函数中，特定函数会返回拼接“done”于此字符串后的新字符串（空格作为间隔）。然而，如果输入字符串为“undo”，特定函数会删除字符串参数历史中的最近字符串值，返回拼接“undone”于此最近字符串后的新字符串（空格作为间隔）。如果输入字符串“undo”时特定函数中的字符串参数历史已为空，那么特定函数会返回字符串“nothing to undo”。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
// CHALLENGE 18
functionmakeHistory(limit) {
const limitNumber = limit; 
let parameterStack = [];
const innerFunction = (stringElement) => {
if(stringElement === "undo"){
if(parameterStack.length == 0) {
return"nothing to undo";
      } else{
return`${parameterStack.pop()} undone`;
      }
    } else{
      parameterStack.push(stringElement);
if(parameterStack.length > limit){
        parameterStack = parameterStack.slice(-limit);
      }
return`${stringElement} done`;
    }
  }
return innerFunction;
}
/*** Uncomment these to check your work! ***/
const myActions = makeHistory(2);
console.log(myActions('jump')); // => should log 'jump done'
console.log(myActions('undo')); // => should log 'jump undone'
console.log(myActions('walk')); // => should log 'walk done'
console.log(myActions('code')); // => should log 'code done'
console.log(myActions('pose')); // => should log 'pose done'
console.log(myActions('undo')); // => should log 'pose undone'
console.log(myActions('undo')); // => should log 'code undone'
console.log(myActions('undo')); // => should log 'nothing to undo'

挑战19 blackjack

问题：

仔细观察测试代码如果你需要帮忙来理解下面的算法描述。

构建blackjack函数，接受参数为一个数组（元素皆为从1到11的数值），返回一个DEALER函数。 DEALER函数会接受两个参数（皆为数值），然后返回一个另外的PLAYER函数。

在第一次调用PLAYER函数时，它会返回输入DEALER函数中的两个数值参数之和。

在第二次调用PLAYER函数时，它会返回下列两种情况中的一种：

  1. 输入blackjack函数的数值型数组的第一个数值加上输入DEALER函数中的两个数值参数之和得到的和，如果和小于等于21，返回此和；
  2. 如果和大于21，返回字符串“bust”。

如果第二次调用PLAYER函数时已返回”bust”，则接下来PLAYER函数的每次调用皆会返回字符串“you are done!”（不过不同于“bust”，输出”you are done!“时不会使用数值型数组中的数值)。如果第二次调用PLAYER函数时并未返回”bust“，则接下来调用PLAYER函数时会返回下列两种情况中的一种：

  1. 最近一次的和值加上数值型数组的下一个数值元素，如果这个求和结果小于等于21的话，返回此和；
  2. 返回“bust”如果求和结果大于21。

再次声明，如果其返回”bust”，则接下来PLAYER函数的每次调用皆会返回字符串“you are done!”，否则，PLAYER函数会继续使用最近一次和值与数值型数组的下一个数值元素求和，一直下去。

你可以假设给定的数值型数组有足够多的数值元素从而会在用完数组元素之前得到“bust”。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
// CHALLENGE 19
functionblackjack(array) {
const dealer = (num1, num2) => {
let first = true; 
let bust = false; 
let sum = num1 + num2; 
const player = () => {
if(first) {
        first = false; 
return sum;
      }
if(bust) {
return"you are done!";
      }
if(sum + array[0] <= 21){
        sum += array.shift();
return sum;
      } else {
        array.shift();
        bust = true;
return"bust";
      }
    }
return player;
  }
return dealer;
}
/*** Uncomment these to check your work! ***/
/*** DEALER ***/
const deal = blackjack([2, 6, 1, 7, 11, 4, 6, 3, 9, 8, 9, 3, 10, 4, 5, 3, 7, 4, 9, 6, 10, 11]);
/*** PLAYER 1 ***/
const i_like_to_live_dangerously = deal(4, 5);
console.log(i_like_to_live_dangerously()); // => should log 9
console.log(i_like_to_live_dangerously()); // => should log 11
console.log(i_like_to_live_dangerously()); // => should log 17
console.log(i_like_to_live_dangerously()); // => should log 18
console.log(i_like_to_live_dangerously()); // => should log 'bust'
console.log(i_like_to_live_dangerously()); // => should log 'you are done!'
console.log(i_like_to_live_dangerously()); // => should log 'you are done!'
/*** BELOW LINES ARE FOR THE BONUS ***/
/*** PLAYER 2 ***/
const i_TOO_like_to_live_dangerously = deal(2, 2);
console.log(i_TOO_like_to_live_dangerously()); // => should log 4
console.log(i_TOO_like_to_live_dangerously()); // => should log 15
console.log(i_TOO_like_to_live_dangerously()); // => should log 19
console.log(i_TOO_like_to_live_dangerously()); // => should log 'bust'
console.log(i_TOO_like_to_live_dangerously()); // => should log 'you are done!
console.log(i_TOO_like_to_live_dangerously()); // => should log 'you are done!
/*** PLAYER 3 ***/
const i_ALSO_like_to_live_dangerously = deal(3, 7);
console.log(i_ALSO_like_to_live_dangerously()); // => should log 10
console.log(i_ALSO_like_to_live_dangerously()); // => should log 13
console.log(i_ALSO_like_to_live_dangerously()); // => should log 'bust'
console.log(i_ALSO_like_to_live_dangerously()); // => should log 'you are done!
console.log(i_ALSO_like_to_live_dangerously()); // => should log 'you are done!'
文章标签：
JavaScript
前端开发
数据安全/隐私保护
算法
存储
关键词：
JavaScript闭包
专项算法
JavaScript算法
算法javascript
JavaScript专项
南京沂洲信息咨询有限公司
目录
相关文章
一缕微风绕指柔
|
19天前
|
自然语言处理 JavaScript 前端开发
深入理解JavaScript中的闭包：原理与实战
【10月更文挑战第12天】深入理解JavaScript中的闭包：原理与实战
一缕微风绕指柔
36 1
那年春天
|
3天前
|
JavaScript 前端开发
js 闭包的优点和缺点
【10月更文挑战第27天】JavaScript闭包是一把双刃剑，在合理使用的情况下，它可以带来很多好处，如实现数据封装、记忆功能和模块化等；但如果不注意其缺点，如内存泄漏、变量共享和性能开销等问题，可能会导致代码出现难以调试的错误和性能问题。因此，在使用闭包时，需要谨慎权衡其优缺点，根据具体的应用场景合理地运用闭包。
那年春天
90 58
那年春天
|
3天前
|
缓存 JavaScript 前端开发
js 闭包
【10月更文挑战第27天】JavaScript闭包是一种强大的特性，它可以用于实现数据隐藏、记忆和缓存等功能，但在使用时也需要注意内存泄漏和变量共享等问题，以确保代码的质量和性能。
那年春天
17 7
土木林森
|
6天前
|
自然语言处理 JavaScript 前端开发
JavaScript闭包：解锁编程潜能，释放你的创造力
【10月更文挑战第25天】本文深入探讨了JavaScript中的闭包，包括其基本概念、创建方法和实践应用。闭包允许函数访问其定义时的作用域链，常用于数据封装、函数柯里化和模块化编程。文章还提供了闭包的最佳实践，帮助读者更好地理解和使用这一强大特性。
土木林森
10 2
游客762btuqu5wybw666
|
22天前
|
设计模式 JavaScript 前端开发
探索JavaScript中的闭包：从基础概念到实际应用
在本文中，我们将深入探讨JavaScript中的一个重要概念——闭包。闭包是一种强大的编程工具，它允许函数记住并访问其所在作用域的变量，即使该函数在其作用域之外被调用。通过详细解析闭包的定义、创建方法以及实际应用场景，本文旨在帮助读者不仅理解闭包的理论概念，还能在实际开发中灵活运用这一技巧。
游客762btuqu5wybw666
15 2
一缕微风绕指柔
|
23天前
|
缓存 JavaScript 前端开发
深入了解JavaScript的闭包：概念与应用
【10月更文挑战第8天】深入了解JavaScript的闭包：概念与应用
一缕微风绕指柔
20 1
zzy的aly
|
23天前
|
JSON 算法 数据可视化
测试专项笔记(一): 通过算法能力接口返回的检测结果完成相关指标的计算（目标检测）
这篇文章是关于如何通过算法接口返回的目标检测结果来计算性能指标的笔记。它涵盖了任务描述、指标分析（包括TP、FP、FN、TN、精准率和召回率），接口处理，数据集处理，以及如何使用实用工具进行文件操作和数据可视化。文章还提供了一些Python代码示例，用于处理图像文件、转换数据格式以及计算目标检测的性能指标。
zzy的aly
36 0
测试专项笔记(一): 通过算法能力接口返回的检测结果完成相关指标的计算（目标检测）
小王老师呀
|
1月前
|
自然语言处理 JavaScript 前端开发
Javascript中的闭包encloure
【10月更文挑战第1天】闭包是 JavaScript 中一种重要的概念，指函数能够访问其定义时的作用域内的变量，即使该函数在其词法作用域之外执行。闭包由函数及其词法环境组成。作用域链和词法作用域是闭包的核心原理。闭包常用于数据隐藏和封装，如模块模式；在异步操作中也广泛应用，如定时器和事件处理。然而，闭包也可能导致内存泄漏和变量共享问题，需谨慎使用。
小王老师呀
28 9
一缕微风绕指柔
|
19天前
|
自然语言处理 JavaScript 前端开发
深入理解JavaScript中的闭包：原理、应用与代码演示
【10月更文挑战第12天】深入理解JavaScript中的闭包：原理、应用与代码演示
一缕微风绕指柔
15 0
小周sir
|
20天前
|
自然语言处理 JavaScript 前端开发
深入理解JavaScript闭包：原理与应用
【10月更文挑战第11天】深入理解JavaScript闭包：原理与应用
小周sir
15 0

热门文章

最新文章

  • 1
    JavaScript基本数据类型分析
  • 2
    javascript模拟实现继承，继承一次父类模板和原型对象
  • 3
    Rhino 是一个完全使用Java语言编写的开源JavaScript实现。Rhino通常用于在Java程序中，为最终用户提供脚本化能力。它被作为J2SE 6上的默认Java脚本化引擎。
  • 4
    Javascript之旅——第四站：parseInt中要注意的坑
  • 5
    JS语法作用域与词法作用域
  • 6
    在JavaScript面向对象编程中使用继承(3)
  • 7
    web worker 是运行在后台的 JavaScript，不会影响页面的性能。
  • 8
    一看就会的Next.js App Router版 -- Routing（上）（一）
  • 9
    YY游戏云的angular js实践总结
  • 10
    HTML，javascript，Json数据在线格式化工具
  • 1
    【算法与数据结构】二叉树（前中后）序遍历2
    38
  • 2
    Machine Learning机器学习之决策树算法 Decision Tree（附Python代码）
    304
  • 3
    从动态规划到贪心算法：最长递增子序列问题的方法全解析
    286
  • 4
    【数据结构】八大排序之计数排序算法
    41
  • 5
    【数据结构】八大排序之归并排序算法
    46
  • 6
    【数据结构】八大排序之快速排序算法
    109
  • 7
    深入理解InnoDB索引数据结构和算法
    326
  • 8
    Java入门高频考查算法逻辑基础知识3-编程篇（超详细18题1.8万字参考编程实现）
    85
  • 9
    sklearn应用线性回归算法
    78
  • 10
    深度思考：雪花算法snowflake分布式id生成原理详解
    1573

    • 相关课程

    更多
  • 智能创作赛（初赛）：相册应用中的故事生成算法介绍
  • 相册服务中的故事生成算法介绍
  • Go语言核心编程 - 数据结构和算法
  • JavaScript入门与实战
  • JavaScript 自学手册文档教程
  • 神经网络概览及算法详解

    • 相关电子书

    更多
  • JavaScript异步编程
  • Delivering Javascript to World
  • 编程语言如何演化-以JS的private为例

    • 相关实验场景

    更多
  • 推荐系统入门之使用ALS算法实现打分预测
  • 欧拉图的构造性证明与算法实现
  • RSA密码算法设计与实现
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月