나는 이것이 무엇을 의미하는지 알고 있었지만 지금은 어려움을 겪고 있습니다 ...
이것이 기본적으로 말하고 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
를 정의했습니다 .count
count
{...}
나는 그것을“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 "은 이제 지역 변수입니다.