나는 이것이 무엇을 의미하는지 알고 있었지만 지금은 어려움을 겪고 있습니다 ...
이것이 기본적으로 말하고 document.onload있습니까?
(function () {
})();
나는 이것이 무엇을 의미하는지 알고 있었지만 지금은 어려움을 겪고 있습니다 ...
이것이 기본적으로 말하고 document.onload있습니까?
(function () {
})();
답변:
그것은이다 즉시-호출 기능 발현 , 또는 인생 에 대한 짧은. 생성 된 직후에 실행됩니다.
이벤트와 같은 이벤트 핸들러와 관련이 없습니다 (예 :) document.onload.
첫 번째 괄호 쌍 내의 부분을 고려하십시오. .... 일반 함수 표현식입니다. 그런 다음 마지막 쌍을보십시오 . 이것은 일반적으로 함수를 호출하기 위해 표현식에 추가됩니다. 이 경우, 우리의 이전 표현.(function(){})();(function(){})();
IIFE 내부에 사용 된 모든 변수 (다른 일반 함수 에서처럼 )는 해당 범위 외부에서 보이지 않기 때문에이 패턴은 전역 네임 스페이스를 오염시키지 않으려 고 할 때 자주 사용됩니다 .
이것이 아마도 다음과 같이 window.onload종종 사용되기 때문에이 구조를 이벤트 핸들러와 혼동하는 이유입니다.
(function(){
// all your code here
var foo = function() {};
window.onload = foo;
// ...
})();
// foo is unreachable here (it’s undefined)
Guffa가 제안한 수정 :
함수는 구문 분석 된 후가 아니라 작성된 직후에 실행됩니다. 코드가 실행되기 전에 전체 스크립트 블록이 구문 분석됩니다. 또한 구문 분석 코드가 자동으로 실행되는 것을 의미하지는 않습니다. 예를 들어 IIFE가 함수 안에 있으면 함수가 호출 될 때까지 실행되지 않습니다.
업데이트 이것은 꽤 인기있는 주제이므로 IIFE는 ES6의 화살표 기능으로 도 작성할 수 있습니다 ( Gajus 가 주석에서 지적한 것처럼 ).
((foo) => {
// do something with foo here foo
})('foo value')
function(){ var foo = '5'; }
그것은 생성 된 직후에 실행되는 익명 함수입니다.
마치 변수에 변수를 할당하고 변수없이 만 바로 사용하는 것과 같습니다.
var f = function () {
};
f();
jQuery에는 비슷한 구조가 있습니다.
$(function(){
});
이것이 ready이벤트 바인딩의 짧은 형식입니다 .
$(document).ready(function(){
});
그러나 위의 두 구성은 IIFE 가 아닙니다 .
IIFE (즉시 호출 된 함수 식)는 즉시 함수를 호출합니다. 이는 정의가 완료된 직후 함수가 실행됨을 의미합니다.
세 가지 더 일반적인 표현 :
// Crockford's preference - parens on the inside
(function() {
console.log('Welcome to the Internet. Please follow me.');
}());
//The OPs example, parentheses on the outside
(function() {
console.log('Welcome to the Internet. Please follow me.');
})();
//Using the exclamation mark operator
//https://stackoverflow.com/a/5654929/1175496
!function() {
console.log('Welcome to the Internet. Please follow me.');
}();
반환 값에 대한 특별한 요구 사항이 없으면 다음과 같이 쓸 수 있습니다.
!function(){}(); // => true
~function(){}(); // => -1
+function(){}(); // => NaN
-function(){}(); // => NaN
또는 다음이 될 수 있습니다.
~(function(){})();
void function(){}();
true && function(){ /* code */ }();
15.0, function(){ /* code */ }();
당신은 쓸 수도 있습니다 :
new function(){ /* code */ }
31.new function(){ /* code */ }() //If no parameters, the last () is not required
31.new는 잘못된 구문입니다
;(function(){}());
즉, 즉시 실행하는 것입니다.
그래서 내가하면 :
var val = (function(){
var a = 0; // in the scope of this function
return function(x){
a += x;
return a;
};
})();
alert(val(10)); //10
alert(val(11)); //21
피들 : http://jsfiddle.net/maniator/LqvpQ/
var val = (function(){
return 13 + 5;
})();
alert(val); //18
이 구문을 즉시 호출 된 함수 식 (IIFE) 이라고하며 즉시 실행됩니다. 인터프리터가 해당 함수에 도달하면 자동으로 호출되는 함수로 생각하십시오.
가장 일반적인 사용 사례 :
가장 일반적인 사용 사례 중 하나는를 통해 작성된 변수의 범위를 제한하는 것 var입니다. 통해 생성 된 변수 var는 범위가 함수로 제한 되므로이 구조 (특정 코드를 중심으로 함수 래퍼)는 변수 범위가 해당 함수에서 누출되지 않도록합니다.
다음 예에서는 count즉시 호출 된 함수 외부에서 사용할 수 없습니다. 즉, 범위가 count함수에서 누출되지 않습니다. 당신은을 받아야 ReferenceError어쨌든 바로 호출 기능을 외부에서 액세스하려고한다.
(function () {
var count = 10;
})();
console.log(count); // Reference Error: count is not defined
ES6 대안 (권장)
ES6, 우리는 지금 통해 생성 된 변수 수 let와 const. 둘 다 블록 범위입니다 ( var기능 범위 와 달리 ).
따라서 위에서 언급 한 유스 케이스에 IIFE의 복잡한 구성을 사용하는 대신 변수 범위가 원하는 블록에서 누출되지 않도록 훨씬 간단한 코드를 작성할 수 있습니다.
{
let count = 10;
}
console.log(count); // ReferenceError: count is not defined
이 예제에서는 중괄호로 만든 코드 블록으로 제한되는 변수 let를 정의했습니다 .countcount{...}
나는 그것을“Curly Jail”이라고 부릅니다.
(function () {
})();
이를 IIFE (즉시 호출 함수 표현식)라고합니다. 유명한 JavaScript 디자인 패턴 중 하나는 현대 모듈 패턴의 핵심입니다. 이름에서 알 수 있듯이 생성 된 직후에 실행됩니다. 이 패턴은 격리 또는 개인 실행 범위를 만듭니다.
ECMAScript 6 이전의 JavaScript는 어휘 범위를 사용 했으므로 IIFE는 블록 범위를 시뮬레이션하는 데 사용되었습니다. ECMAScript 6에서는 let및 const키워드를 소개하여 블록 범위를 지정할 수 있습니다.
어휘 범위 문제에 대한 참조
인생의 사용의 성능 이점은 같은 일반적으로 사용되는 전역 개체 전달하는 능력이다 window, document범위 조회를 줄여 인수로 등. JavaScript는 로컬 범위에서 속성을 찾고 전역 범위까지 체인을 확장합니다. 따라서 로컬 범위에서 전역 객체에 액세스하면 아래와 같이 조회 시간이 줄어 듭니다.
(function (globalObj) {
//Access the globalObj
})(window);
아니요,이 구문은 단지 명명 범위를 만듭니다. 부품이 파손되면 외부가 있음을 알 수 있습니다
(...)();
이것이 함수 호출입니다. 괄호 안에는 다음이 있습니다.
function() {}
그것은 익명의 기능입니다. 구문 내에서 var 로 선언 된 모든 것은 동일한 구문 내에서만 볼 수 있으며 전역 네임 스페이스를 오염시키지 않습니다.
이것은 Javascript에서 즉시 호출되는 함수 표현식입니다.
JS의 IIFE를 이해하려면 다음과 같이 분류하십시오.
a = 10 output = 10 (1+3) output = 4
// Function Expression var greet = function(name){ return 'Namaste' + ' ' + name; } greet('Santosh');
함수 표현식 작동 방식 :
-JS 엔진이 처음 실행될 때 (실행 컨텍스트-작성 단계)이 함수 (오른쪽 = 위)는 메모리에서 실행되거나 저장되지 않습니다. 변수 'greet'에는 JS 엔진에 의해 '정의되지 않은'값이 할당됩니다.
-실행 (실행 컨텍스트-실행 단계) 중에 funtion 오브젝트가 즉시 작성되고 ( 아직 실행되지 않음 ) 'greet'변수에 지정되며 'greet ('somename ')'을 사용하여 호출 할 수 있습니다.
3. 즉시 호출 된 Funtion Expression :
예:
// IIFE
var greeting = function(name) {
return 'Namaste' + ' ' + name;
}('Santosh')
console.log(greeting) // Namaste Santosh.
IIFE 작동 방식 :
-함수 선언 직후 '()'에 주목하십시오. 모든 funtion 객체에는 호출 가능한 'CODE'속성이 있습니다. 그리고 '()'중괄호를 사용하여 호출하거나 호출 할 수 있습니다.
-여기서 실행 (Execution Context-Execute Phase) 중에 함수 오브젝트가 작성되고 동시에 실행됩니다.
이제 함수 변수를 사용하는 대신 인사말 변수에 리턴 값 (string)이 있습니다.
JS에서 IIFE의 일반적인 사용 사례 :
다음 IIFE 패턴이 매우 일반적으로 사용됩니다.
// IIFE
// Spelling of Function was not correct , result into error
(function (name) {
var greeting = 'Namaste';
console.log(greeting + ' ' + name);
})('Santosh');
따라서이 함수는 동시에 생성되고 실행됩니다 (IIFE).
IIFE의 중요한 사용 사례 :
IIFE는 코드를 안전하게 유지합니다.
-함수 인 IIFE에는 자체 실행 컨텍스트가 있습니다. 즉, 함수 내에 작성된 모든 변수는이 함수에 로컬이며 글로벌 실행 컨텍스트와 공유되지 않습니다.
iife.js와 함께 내 응용 프로그램에 사용 된 다른 JS 파일 (test1.js)이 있다고 가정합니다 (아래 참조).
// test1.js
var greeting = 'Hello';
// iife.js
// Spelling of Function was not correct , result into error
(function (name) {
var greeting = 'Namaste';
console.log(greeting + ' ' + name);
})('Santosh');
console.log(greeting) // No collision happens here. It prints 'Hello'.
따라서 IIFE를 사용하면 실수로 전역 객체와 충돌하지 않는 안전한 코드 를 작성할 수 있습니다.
그것은 자체 호출 익명 함수 입니다.
자체 호출 기능에 대한 W3Schools 설명을 확인하십시오 .
함수 표현은 "자기 호출"로 만들 수 있습니다.
자체 호출 표현식은 호출되지 않고 자동으로 호출 (시작)됩니다.
표현식 뒤에 ()가 있으면 함수 표현식이 자동으로 실행됩니다.
함수 선언을 자체 호출 할 수 없습니다.
(function named(){console.log("Hello");}());<-자체 실행 명명 된 함수
이것은 자체 호출 익명 기능입니다. 정의되는 동안 실행됩니다. 이는이 함수가 정의되고 정의 직후에 자신을 호출 함을 의미합니다.
구문에 대한 설명은 다음과 같습니다. 첫 번째 ()괄호 안의 함수는 이름이없는 함수이며 다음 ();괄호로 정의 될 때 호출되는 것을 이해할 수 있습니다. 그리고 ()첫 번째 괄호 안에있는 함수 에서이 두 번째 괄호 안에 인수를 전달할 수 있습니다 . 이 예제를보십시오 :
(function(obj){
// Do something with this obj
})(object);
여기서 전달하는 '객체'는 함수 시그니처에서 잡아서 'obj'로 함수 내에서 액세스 할 수 있습니다.
여기에서 시작하십시오 :
var b = 'bee';
console.log(b); // global
기능에 넣고 더 이상 글로벌하지 않습니다 -기본 목표.
function a() {
var b = 'bee';
console.log(b);
}
a();
console.log(b); // ReferenceError: b is not defined -- *as desired*
함수를 즉시 호출하십시오.
function a() {
var b = 'bee';
console.log(b);
}(); // SyntaxError: Expected () to start arrow function, but got ';' instead of '=>'
구문 오류를 피하려면 괄호를 사용하십시오.
(function a() {
var b = 'bee';
console.log(b);
})(); // OK now
기능 이름을 생략 할 수 있습니다.
(function () { // no name required
var b = 'bee';
console.log(b);
})();
그보다 더 복잡 할 필요는 없습니다.
Uncaught SyntaxError: Unexpected token )화살표 함수에 대한 언급이 아니라 실제로 얻 습니다. 화살표 기능 오류가 발생하여 바이올린을 공유 할 수 있습니까?
자체 실행 익명 기능. 생성 되 자마자 실행됩니다.
이것이 유용한 짧은 더미 예제는 다음과 같습니다.
function prepareList(el){
var list = (function(){
var l = [];
for(var i = 0; i < 9; i++){
l.push(i);
}
return l;
})();
return function (el){
for(var i = 0, l = list.length; i < l; i++){
if(list[i] == el) return list[i];
}
return null;
};
}
var search = prepareList();
search(2);
search(3);
따라서 매번 목록을 작성하는 대신 한 번만 작성하십시오 (오버 헤드가 적음).
자체 실행 기능은 일반적으로 컨텍스트를 캡슐화하고 이름 충돌을 피하는 데 사용됩니다. (function () {..}) () 안에서 정의한 변수는 전역 변수가 아닙니다.
코드
var same_name = 1;
var myVar = (function() {
var same_name = 2;
console.log(same_name);
})();
console.log(same_name);
이 출력을 생성합니다.
2
1
이 구문을 사용하면 JavaScript 코드의 다른 곳에서 선언 된 전역 변수와 충돌하지 않아도됩니다.
var same_name = 1; var myVar = function() { var same_name = 2; console.log(same_name); }; myVar(); console.log(same_name); 같은 결과를 얻을 것입니다.
이를 IIFE-즉시 호출 된 함수식이라고합니다. 다음은 구문과 사용법을 보여주는 예입니다. 변수를 사용하지 않고 기능까지만 사용하도록 범위를 지정하는 데 사용됩니다.
(function () {
function Question(q,a,c) {
this.q = q;
this.a = a;
this.c = c;
}
Question.prototype.displayQuestion = function() {
console.log(this.q);
for (var i = 0; i < this.a.length; i++) {
console.log(i+": "+this.a[i]);
}
}
Question.prototype.checkAnswer = function(ans) {
if (ans===this.c) {
console.log("correct");
} else {
console.log("incorrect");
}
}
var q1 = new Question('Is Javascript the coolest?', ['yes', 'no'], 0);
var q2 = new Question('Is python better than Javascript?', ['yes', 'no', 'both are same'], 2);
var q3 = new Question('Is Javascript the worst?', ['yes', 'no'], 1);
var questions = [q1, q2, q3];
var n = Math.floor(Math.random() * questions.length)
var answer = parseInt(prompt(questions[n].displayQuestion()));
questions[n].checkAnswer(answer);
})();
IIFE (즉시 호출 된 함수 표현식)는 스크립트가로드되고 사라지는 즉시 실행되는 함수입니다.
iife.js라는 파일로 작성된 아래 함수를 고려하십시오.
(function(){
console.log("Hello Stackoverflow!");
})();
위의 코드는 iife.js를로드하자마자 실행되며 ' Hello Stackoverflow! '는 개발자 도구'콘솔에 있습니다.
자세한 설명은 즉시 호출 된 함수 표현식 (IIFE)을 참조하십시오.
IIFE (즉시 호출 된 함수 표현식)는 작성 되 자마자 실행되는 함수입니다. 이벤트 또는 비동기 실행과 연결되어 있지 않습니다. 아래와 같이 IIFE를 정의 할 수 있습니다.
(function() {
// all your code here
// ...
})();
첫 번째 괄호 쌍 function () {...}은 괄호 안의 코드를 표현식으로 변환합니다. 두 번째 괄호 쌍은 표현식의 결과 함수를 호출합니다.
는 IIFE또한 자체 호출하는 익명 함수로 설명 될 수있다. 가장 일반적인 사용법은 var를 통해 만들어진 변수의 범위를 제한하거나 이름 충돌을 피하기 위해 컨텍스트를 캡슐화하는 것입니다.
다음 코드 :
(function () {
})();
라고 즉시 호출 함수 표현식 (인생).
( yourcode )Javascript 의 연산자가이를 표현식으로 강제 실행 하기 때문에 함수 표현식이라고합니다 . 함수 표현식 과 함수 선언 의 차이점 은 다음과 같습니다.
// declaration:
function declaredFunction () {}
// expressions:
// storing function into variable
const expressedFunction = function () {}
// Using () operator, which transforms the function into an expression
(function () {})
식은 단순히 단일 값 으로 평가 될 수있는 코드 묶음입니다 . 위 예제의 표현식의 경우이 값은 단일 함수 객체 입니다.
함수 객체로 평가되는 표현식을 얻은 후 연산자를 사용 하여 함수 객체를 즉시 호출 할 수 있습니다 (). 예를 들면 다음과 같습니다.
(function() {
const foo = 10; // all variables inside here are scoped to the function block
console.log(foo);
})();
console.log(foo); // referenceError foo is scoped to the IIFE
큰 코드 기반을 다루거나 다양한 라이브러리를 가져올 때 이름 충돌의 가능성이 높아집니다. IIFE 내부에 관련된 (따라서 동일한 변수를 사용하는) 코드의 특정 부분을 작성할 때 모든 변수와 함수 이름은 IIFE의 함수 괄호로 범위가 지정됩니다 . 이렇게하면 이름 충돌의 가능성이 줄어들고보다 부주의하게 이름을 지정할 수 있습니다 (예 : 접두사를 붙일 필요가 없습니다).
이 기능을 자체 호출 기능이라고합니다. 자체 호출 (자체 실행이라고도 함) 함수는 정의 직후에 호출 (호출)되는 이름없는 (익명) 함수입니다. 자세한 내용은 여기를 참조하십시오
이러한 함수는 함수가 정의 될 때 함수가 즉시 호출되어 별도의 라인에서 호출하는 것과 비교하여 시간과 여분의 코드 라인을 절약합니다.
예를 들면 다음과 같습니다.
(function() {
var x = 5 + 4;
console.log(x);
})();
이것이 왜 이것을 사용하는지에 대한 더 자세한 설명입니다.
"IIFE를 사용하는 주된 이유는 데이터 프라이버시를 얻는 것입니다. JavaScript의 var는 변수를 포함하는 함수로 변수를 다루기 때문에 IIFE 내에 선언 된 모든 변수는 외부 세계에서 액세스 할 수 없습니다."
함수 표현식이며 즉시 호출 된 함수 표현식 (IIFE)을 나타냅니다. IIFE는 생성 된 직후 실행되는 기능입니다. 따라서 실행이 호출 될 때까지 기다려야하는 함수에 대해 IIFE가 즉시 실행됩니다. IIFE를 예로 들어 봅시다. add 함수가 두 개의 정수를 인수로 취하고 합을 리턴하여 add 함수를 IIFE로 만들 수 있다고 가정 해보십시오.
1 단계 : 함수 정의
function add (a, b){
return a+b;
}
add(5,5);
2 단계 : 전체 함수 선언을 괄호로 묶어 함수 호출
(function add (a, b){
return a+b;
})
//add(5,5);
3 단계 : 함수를 즉시 실행하려면 호출에서 'add'텍스트를 제거하십시오.
(function add (a, b){
return a+b;
})(5,5);
IFFE를 사용하는 주된 이유 는 함수 내에서 개인 범위를 유지하기 위해서입니다. 자바 스크립트 코드 내에서 전역 변수를 재정의하지 않아야합니다. 때로는 실수로 전역 변수를 대체하는 변수를 정의 할 수 있습니다. 예를 들어 봅시다. iffe.html이라는 html 파일이 있고 body 태그 안의 코드가
<body>
<div id = 'demo'></div>
<script>
document.getElementById("demo").innerHTML = "Hello JavaScript!";
</script>
</body>
글쎄, 위의 코드는 질문없이 실행됩니다. 이제 우연히 또는 의도적으로 document라는 변수를 삭제했다고 가정합니다.
<body>
<div id = 'demo'></div>
<script>
document.getElementById("demo").innerHTML = "Hello JavaScript!";
const document = "hi there";
console.log(document);
</script>
</body>
구성 불가능한 전역 속성 문서를 다시 선언 하면 SyntaxError :에 선언됩니다.
그러나 변수 이름 문서를 지우려는 경우 IFFE를 사용하여 수행 할 수 있습니다.
<body>
<div id = 'demo'></div>
<script>
(function(){
const document = "hi there";
this.document.getElementById("demo").innerHTML = "Hello JavaScript!";
console.log(document);
})();
document.getElementById("demo").innerHTML = "Hello JavaScript!";
</script>
</body>
산출:
다른 예제로 시도해 봅시다. 다음과 같은 계산기 객체가 있다고 가정합니다.
<body>
<script>
var calculator = {
add:function(a,b){
return a+b;
},
mul:function(a,b){
return a*b;
}
}
console.log(calculator.add(5,10));
</script>
</body>
글쎄, 그것은 매력처럼 작동합니다. 우연히 계산기 객체의 값을 다시 할당하면 어떻게 될까요?
<body>
<script>
var calculator = {
add:function(a,b){
return a+b;
},
mul:function(a,b){
return a*b;
}
}
console.log(calculator.add(5,10));
calculator = "scientific calculator";
console.log(calculator.mul(5,5));
</script>
</body>
예, TypeError로 끝날 것입니다 : calculator.mul은 함수가 아닙니다 iffe.html
그러나 IFFE의 도움으로 다른 변수 이름 계산기를 만들어 사용할 수있는 개인 범위를 만들 수 있습니다.
<body>
<script>
var calculator = {
add:function(a,b){
return a+b;
},
mul:function(a,b){
return a*b;
}
}
var cal = (function(){
var calculator = {
sub:function(a,b){
return a-b;
},
div:function(a,b){
return a/b;
}
}
console.log(this.calculator.mul(5,10));
console.log(calculator.sub(10,5));
return calculator;
})();
console.log(calculator.add(5,10));
console.log(cal.div(10,5));
</script>
</body>
나는 2 세트의 대괄호가 약간 혼란 스럽지만 Google 예제에서 다른 사용법을 보았습니다. 비슷한 것을 사용했습니다. 이것이 더 잘 이해하는 데 도움이되기를 바랍니다.
var app = window.app || (window.app = {});
console.log(app);
console.log(window.app);
따라서 windows.app정의되지 않은 경우 window.app = {}즉시 실행되므로 조건 평가 중에 window.app할당 {}되므로 결과가 모두 app되고 window.app이제 {}이므로 콘솔 출력은 다음과 같습니다.
Object {}
Object {}
일반적으로 JavaScript 코드는 응용 프로그램에서 전체 범위를 갖습니다. 전역 변수를 선언하면 개발의 다른 영역에서 다른 목적으로 동일한 복제 변수를 사용할 가능성이 있습니다. 이 중복으로 인해 약간의 오류가 발생할 수 있습니다. 따라서 함수 expression을 즉시 호출하여이 전역 변수를 피할 수 있습니다.이 표현식은 자체 실행 식입니다 .IIFE 내부에서 코드를 만들 때 표현식 전역 변수는 로컬 범위 및 로컬 변수와 같습니다.
IIFE 를 만들 수있는 두 가지 방법
(function () {
"use strict";
var app = angular.module("myModule", []);
}());
또는
(function () {
"use strict";
var app = angular.module("myModule", []);
})();
위의 코드 스 니펫에서 " var app "은 이제 지역 변수입니다.