JavaScript에서 (function () {}) () 구문은 무엇입니까?


790

나는 이것이 무엇을 의미하는지 알고 있었지만 지금은 어려움을 겪고 있습니다 ...

이것이 기본적으로 말하고 document.onload있습니까?

(function () {

})();

20
btw,이 기능을 '자기 호출'이라고 부르는 사람들이 있지만 분명히 그렇지 않습니다. iife 라는 용어 는 정확성이라는 장점이 있습니다.
AakashM

6
이것은이 구성에 대한 훌륭한 설명을 제공합니다. "IIFE"라는 용어가 시작된 곳이기도합니다. benalman.com/news/2010/11/…
jeremysawesome


2
이 구문의 이름은 여기를 참조하십시오 . 이 구성목적기술적 인 설명 ( 여기에서도 ) 에 대해 읽으십시오 . 구문을 보려면 괄호가 왜 필요한지 그리고 어디로 가야 하는지 살펴보십시오 .
Bergi

답변:


854

그것은이다 즉시-호출 기능 발현 , 또는 인생 에 대한 짧은. 생성 된 직후에 실행됩니다.

이벤트와 같은 이벤트 핸들러와 관련이 없습니다 (예 :) 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')

@ gion_13 생성 단계와 구문 분석 단계의 차이점은 무엇입니까?
akantoword

1
@ jlei 내가 보는대로 js 프로그램의 라이프 사이클에는 파싱, 생성 / 컴파일, 실행 단계가 포함됩니다. 실제 구현 (및 이름 지정 :)))은 브라우저마다 다를 수 있지만 구문 분석 오류, 게양 및 런타임 오류를 관찰하여 코드에서 이러한 단계를 결정할 수 있습니다. 나는 개인적으로 이것에 대해 많은 리소스를 찾지 못했습니다. 왜냐하면 너무 낮아서 프로그래머가 제어 할 수있는 것이 아니기 때문입니다. 이 SO 게시물에서 일종의 설명을 찾을 수 있습니다. stackoverflow.com/a/34562772/491075
gion_13

@sam firat, varianle 선언과 새로운 키워드가 있습니다. 이것은 귀하의 예에서 생성자 (익명 함수 표현식)에 의해 정의 된 새로운 obiect를 인스턴스화하고 IIFE 예에서와 같이 finction을 호출하는 것이 아니라 새로운 연산자를 통해 호출된다는 것을 의미합니다. 그 기능은 내용에 대한 폐쇄 역할을하지만 확실히 다른 유스 케이스입니다.
gion_13

이것이 어떻게 글로벌 네임 스페이스를 오염 시키는가? 어쨌든 foo는 함수 외부에서 사용할 수 없습니다. function(){ var foo = '5'; }
Pankaj 2016 년

1
@Pankaj — 자체적으로 가져옵니다. 구문 상으로 유효한 JS조차 아닙니다 (함수 표현식이지만 표현식 컨텍스트에는 없으므로 구문 오류로 처리됩니다).
Quentin

109

그것은 생성 된 직후에 실행되는 익명 함수입니다.

마치 변수에 변수를 할당하고 변수없이 만 바로 사용하는 것과 같습니다.

var f = function () {
};
f();

jQuery에는 비슷한 구조가 있습니다.

$(function(){
});

이것이 ready이벤트 바인딩의 짧은 형식입니다 .

$(document).ready(function(){
});

그러나 위의 두 구성은 IIFE 가 아닙니다 .


83
그들이 호출하고 이후 DOM이 아닌 준비 때 마지막 두 정말 IIFEs하지 즉시
svvac가

15
@ swordofpain : 예, 맞습니다. IIFE가 아닙니다.
Guffa

두 번째 스 니펫을 고려한 @swordofpain; 함수의 끝에 add () 값을 IIFE로 바꾸면 어떤 값이 있습니까?
timebandit

끝에 세미콜론이 필요합니까?
FrenkyB 2016 년

@FrenkyB 필요하지는 않지만 권장되지는 않습니다 (자바 스크립트에서는 세미콜론이 실제로 필요하지 않지만 좋은 방법입니다). 이들 각각은 함수 선언이 아닌 익명 함수를 포함하는 명령문입니다.
레디 빈

52

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

4
마지막 하나 31.new는 잘못된 구문입니다
cat

9
같은 것을 쓰는 방법이 왜 이렇게 많은가요? !! > _ <이 언어가 마음에 들지 않습니다
Awesome_girl

6
aaand 승자는;(function(){}());
Roko C. Buljan

Crockford 환경 설정 설명은 매우 유용했습니다. 예를 들어 jQuery 작은 펍 서브 요지 가 한 버전에서 다른 버전으로 전환 (파일 끝에서 변경 사항을 볼 수 있음)과 같은 차이점을 설명했습니다. 왜 그런지 알아 내지 마라.
icc97

1
@Awesome_girl : 같은 것을 쓰는 많은 방법이있는 것은 아닙니다. JS에는 모든 값 유형에서 작동 할 수있는 연산자가있는 느슨한 유형 시스템이 있습니다. 당신은 할 수 있고 1 - 1쉽게 할 수 있습니다 true - function(){}. 그것은 하나의 것 (중위 뺄셈 연산자)이지만 다르지만 무의미한 피연산자가 있습니다.

31

익명 함수를 선언 한 다음 호출합니다.

(function (local_arg) {
   // anonymous function
   console.log(local_arg);
})(arg);

"인수"는 함수 내 로컬 컨텍스트에서 사용되는 "arg"로 참조되는 외부 변수 인 것 같습니다.
Dalibor

@Dalibor arguments특별하다 ; 내 추측은 응답자가 방금 이름이 바뀐 곳입니다
cat

29

즉, 즉시 실행하는 것입니다.

그래서 내가하면 :

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

1
나는 그것이 자기 호출을 증명하는 것을 얻지 못합니까?
Exitos

1
@Exitos는 해당 함수를 반환하기 때문입니다. 두 번째 예를 들어 보겠습니다.
Naftali 일명 Neal

매우 이해하기 쉬움 +1
Adiii

24

이 구문을 즉시 호출 된 함수 식 (IIFE) 이라고하며 즉시 실행됩니다. 인터프리터가 해당 함수에 도달하면 자동으로 호출되는 함수로 생각하십시오.

가장 일반적인 사용 사례 :

가장 일반적인 사용 사례 중 하나는를 통해 작성된 변수의 범위를 제한하는 것 var입니다. 통해 생성 된 변수 var는 범위가 함수로 제한 되므로이 구조 (특정 코드를 중심으로 함수 래퍼)는 변수 범위가 해당 함수에서 누출되지 않도록합니다.

다음 예에서는 count즉시 호출 된 함수 외부에서 사용할 수 없습니다. 즉, 범위가 count함수에서 누출되지 않습니다. 당신은을 받아야 ReferenceError어쨌든 바로 호출 기능을 외부에서 액세스하려고한다.

(function () { 
    var count = 10;
})();
console.log(count);  // Reference Error: count is not defined

ES6 대안 (권장)

ES6, 우리는 지금 통해 생성 된 변수 수 letconst. 둘 다 블록 범위입니다 ( var기능 범위 와 달리 ).

따라서 위에서 언급 한 유스 케이스에 IIFE의 복잡한 구성을 사용하는 대신 변수 범위가 원하는 블록에서 누출되지 않도록 훨씬 간단한 코드를 작성할 수 있습니다.

{ 
    let count = 10;
}
console.log(count);  // ReferenceError: count is not defined

이 예제에서는 중괄호로 만든 코드 블록으로 제한되는 변수 let를 정의했습니다 .countcount{...}

나는 그것을“Curly Jail”이라고 부릅니다.


10
나는 Curly Jail 네이밍을 좋아한다 . 어쩌면 그것은 스틱 것입니다 :)
gion_13

15
(function () {
})();

이를 IIFE (즉시 호출 함수 표현식)라고합니다. 유명한 JavaScript 디자인 패턴 중 하나는 현대 모듈 패턴의 핵심입니다. 이름에서 알 수 있듯이 생성 된 직후에 실행됩니다. 이 패턴은 격리 또는 개인 실행 범위를 만듭니다.

ECMAScript 6 이전의 JavaScript는 어휘 범위를 사용 했으므로 IIFE는 블록 범위를 시뮬레이션하는 데 사용되었습니다. ECMAScript 6에서는 letconst키워드를 소개하여 블록 범위를 지정할 수 있습니다. 어휘 범위 문제에 대한 참조

IIFE로 블록 범위 시뮬레이션

인생의 사용의 성능 이점은 같은 일반적으로 사용되는 전역 개체 전달하는 능력이다 window, document범위 조회를 줄여 인수로 등. JavaScript는 로컬 범위에서 속성을 찾고 전역 범위까지 체인을 확장합니다. 따라서 로컬 범위에서 전역 객체에 액세스하면 아래와 같이 조회 시간이 줄어 듭니다.

(function (globalObj) {
//Access the globalObj
})(window);

IIFE의 두 번째 괄호를 이해하기 위해 요점을 제공해 주셔서 감사합니다. 또한 정의에서 정의하여 전역 변수의 조회 시간 이점을 명확히하기 위해
Arsal

11

아니요,이 구문은 단지 명명 범위를 만듭니다. 부품이 파손되면 외부가 있음을 알 수 있습니다

(...)();

이것이 함수 호출입니다. 괄호 안에는 다음이 있습니다.

function() {}

그것은 익명의 기능입니다. 구문 내에서 var 로 선언 된 모든 것은 동일한 구문 내에서만 볼 수 있으며 전역 네임 스페이스를 오염시키지 않습니다.


11

이것은 Javascript에서 즉시 호출되는 함수 표현식입니다.

JS의 IIFE를 이해하려면 다음과 같이 분류하십시오.

  1. 표현식 : 값을 반환하는 것
    예 : 크롬 콘솔에서 다음을 시도하십시오. 이것들은 JS의 표현입니다.
a = 10 
output = 10 
(1+3) 
output = 4
  1. 함수 표현 :
    예 :
// 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');
  • 우리는 여기서 두 가지 일을하고 있습니다. a) 함수 표현식을 중괄호 ()로 묶습니다. 이것은 구문 파서에게 () 안에 배치 된 것은 표현식 (이 경우 함수 표현식)이며 유효한 코드입니다.
    b) 우리는 마지막에 ()를 사용 하여이 기능을 동시에 호출합니다.

따라서이 함수는 동시에 생성되고 실행됩니다 (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를 사용하면 실수로 전역 객체와 충돌하지 않는 안전한 코드작성할 수 있습니다.


IIFE 내부에서 함수를 만들면 다른 js 또는 jsx 파일, 즉 반응 구성 요소에서 어떻게 액세스 할 수 있습니까?
stone rock

IIFE를 사용하지 않더라도 인사말 변수는 전역 인사말 변수와 충돌하지 않습니다. 그렇다면 이점은 무엇입니까?
Willy David Jr

6

그것은 자체 호출 익명 함수 입니다.

자체 호출 기능에 대한 W3Schools 설명을 확인하십시오 .

함수 표현은 "자기 호출"로 만들 수 있습니다.

자체 호출 표현식은 호출되지 않고 자동으로 호출 (시작)됩니다.

표현식 뒤에 ()가 있으면 함수 표현식이 자동으로 실행됩니다.

함수 선언을 자체 호출 할 수 없습니다.


3
(function named(){console.log("Hello");}());<-자체 실행 명명 된 함수
bryc

@bryc 왜 이름이 필요없는 함수의 이름을 지정하겠습니까?
RicardoGonzales 2012 년

2
@RicardoGonzales 재귀 것 같아요
bryc

5

이것은 자체 호출 익명 기능입니다. 정의되는 동안 실행됩니다. 이는이 함수가 정의되고 정의 직후에 자신을 호출 함을 의미합니다.

구문에 대한 설명은 다음과 같습니다. 첫 번째 ()괄호 안의 함수는 이름이없는 함수이며 다음 ();괄호로 정의 될 때 호출되는 것을 이해할 수 있습니다. 그리고 ()첫 번째 괄호 안에있는 함수 에서이 두 번째 괄호 안에 인수를 전달할 수 있습니다 . 이 예제를보십시오 :

(function(obj){
    // Do something with this obj
})(object);

여기서 전달하는 '객체'는 함수 시그니처에서 잡아서 'obj'로 함수 내에서 액세스 할 수 있습니다.


2
이 질문에는 이미 허용 된 답변이 있으며 귀하의 답변에 아직 허용되지 않은 답변은 추가되지 않았습니다. 따라서이 답변을 작성할 필요는 전혀 없었습니다.
Aadit M Shah

3
나는 여러 개의 답을 읽는 것을 좋아하는데, 때때로 하나 또는 다른 것의 표현이 차이를 만듭니다.

두 번째 괄호 세트가 무엇인지 알려주기 때문에 추가되었다고 생각했습니다. 적어도 내가 본 것은 분명했습니다.
johnny

내 좋아하는 ans. 샘플 IIFE의 양쪽 끝에는 매개 변수가 있으며 두 매개 변수의 매핑은 명확합니다.
Stephen W. Wright

4

여기에서 시작하십시오 :

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);
})();

그보다 더 복잡 할 필요는 없습니다.


2
구문 오류는 화살표 기능에 관한 것입니다. 내가 이해하는 것처럼 js의 새로운 기능이며 몇 년 전에는 존재하지 않았지만 IIFE는 그랬습니다. 따라서 괄호는 아마도 구문 오류를 피하기 위해 원래 사용되었지만 다른 것입니까?
JCarlosR

@JCarlos 질문에 대답 해 주시겠습니까? IIFE가 화살표 기능보다 훨씬 앞서 왔다고 지적하면서 래핑이 필요한 이유를 이해하는 데 도움이 될 것입니다.
Script47

@ Script47 댓글에 JCarlos의 질문에 대한 답변이 없습니다. 새 질문을 작성하여 게시 할 수 있으며 좋은 답변을 얻을 수 있습니다.
Jim Flood

@JCarlos 내가 오류를 던지는 것을 실행하면 실제로 Uncaught SyntaxError: Unexpected token )화살표 함수에 대한 언급이 아니라 실제로 얻 습니다. 화살표 기능 오류가 발생하여 바이올린을 공유 할 수 있습니까?
Script47

2

자체 실행 익명 기능. 생성 되 자마자 실행됩니다.

이것이 유용한 짧은 더미 예제는 다음과 같습니다.

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);

따라서 매번 목록을 작성하는 대신 한 번만 작성하십시오 (오버 헤드가 적음).


1
작성된대로 검색하면 각 호출에 대한 목록이 다시 작성됩니다. 이를 피하려면 (1) 목록을 만들고 (2) 검색 기능을 방금 만든 목록에 액세스 할 수있는 클로저로 반환해야합니다. 익명의 자체 호출 양식을 사용하면 쉽게 할 수 있습니다. jsfiddle.net/BV4bT를 참조하십시오 .
George

당신은 설명 할 수 있습니다 ... 적은 오버 헤드 ..i dint이 부분을 이해
HIRA THAKUR

2
오버 헤드는 필요하지 않은 수행 된 작업을 의미합니다. 각 함수 호출에서 배열을 채우는 것은 필요하지 않으므로 예제의 배열은 자체 실행으로 채워집니다. 처음으로 익명 기능. 그러나 나는 내 자신의 대답에서 실수를 한 것 같습니다. 적절한 예를 보려면 George의 의견에있는 링크를 참조하십시오.
usoban

2

자체 실행 기능은 일반적으로 컨텍스트를 캡슐화하고 이름 충돌을 피하는 데 사용됩니다. (function () {..}) () 안에서 정의한 변수는 전역 변수가 아닙니다.

코드

var same_name = 1;

var myVar = (function() {
    var same_name = 2;
    console.log(same_name);
})();

console.log(same_name);

이 출력을 생성합니다.

2
1

이 구문을 사용하면 JavaScript 코드의 다른 곳에서 선언 된 전역 변수와 충돌하지 않아도됩니다.


1
myVar가 먼저 실행되므로 출력은 2, 1이됩니다.
Dalibor

1
설명은 기능 범위를 설명하는 데는 좋지만 즉시 실행되는 이유를 설명하는 데는 부족합니다. 변수에 할당하는 것은 자기 패배이며 또한 두 번 이상 실행될 수 있습니다. var same_name = 1; var myVar = function() { var same_name = 2; console.log(same_name); }; myVar(); console.log(same_name); 같은 결과를 얻을 것입니다.
domenicr

2

이를 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);
})();

1

IIFE (즉시 호출 된 함수 표현식)는 스크립트가로드되고 사라지는 즉시 실행되는 함수입니다.

iife.js라는 파일로 작성된 아래 함수를 고려하십시오.

(function(){
       console.log("Hello Stackoverflow!");
   })();

위의 코드는 iife.js를로드하자마자 실행되며 ' Hello Stackoverflow! '는 개발자 도구'콘솔에 있습니다.

자세한 설명은 즉시 호출 된 함수 표현식 (IIFE)을 참조하십시오.


1

또 하나의 유스 케이스는 캐시 오브젝트가 전역이 아닌 메모리 화입니다.

var calculate = (function() {
  var cache = {};
  return function(a) {

    if (cache[a]) {
      return cache[a];
    } else {
      // Calculate heavy operation
      cache[a] = heavyOperation(a);
      return cache[a];
    }
  }
})();

0

IIFE (즉시 호출 된 함수 표현식)는 작성 되 자마자 실행되는 함수입니다. 이벤트 또는 비동기 실행과 연결되어 있지 않습니다. 아래와 같이 IIFE를 정의 할 수 있습니다.

(function() {
     // all your code here
     // ...
})();

첫 번째 괄호 쌍 function () {...}은 괄호 안의 코드를 표현식으로 변환합니다. 두 번째 괄호 쌍은 표현식의 결과 함수를 호출합니다.

IIFE또한 자체 호출하는 익명 함수로 설명 될 수있다. 가장 일반적인 사용법은 var를 통해 만들어진 변수의 범위를 제한하거나 이름 충돌을 피하기 위해 컨텍스트를 캡슐화하는 것입니다.


0

자체 호출 익명 함수가 사용되는 이유는 호출하려는 IS 코드 (함수 및 변수에 대한 범위를 제공함)를 "설정"하기 때문에 다른 코드에서 호출해서는 안되기 때문입니다.

다시 말해, 프로그램 시작시 "클래스를 만드는"프로그램과 같습니다. 인스턴스화 (자동으로) 된 후 사용 가능한 유일한 기능은 익명 함수에 의해 반환되는 기능뿐입니다. 숨겨진 상태의 함수는 모든 상태 (범위 작성 중에 설정된 변수)와 함께 여전히 있습니다.

매우 시원합니다.


0

다음 코드 :

(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의 함수 괄호로 범위가 지정됩니다 . 이렇게하면 이름 충돌의 가능성이 줄어들고보다 부주의하게 이름을 지정할 수 있습니다 (예 : 접두사를 붙일 필요가 없습니다).


0

ES6 구문에서 (이 페이지에 계속 방문하면서 빠른 예를 찾기 위해 직접 게시) :

// simple
const simpleNumber = (() => {
  return true ? 1 : 2
})()

// with param
const isPositiveNumber = ((number) => {
  return number > 0 ? true : false
})(4)

0

이 기능을 자체 호출 기능이라고합니다. 자체 호출 (자체 실행이라고도 함) 함수는 정의 직후에 호출 (호출)되는 이름없는 (익명) 함수입니다. 자세한 내용은 여기를 참조하십시오

이러한 함수는 함수가 정의 될 때 함수가 즉시 호출되어 별도의 라인에서 호출하는 것과 비교하여 시간과 여분의 코드 라인을 절약합니다.

예를 들면 다음과 같습니다.

(function() {
    var x = 5 + 4;
    console.log(x);
})();



0

함수 표현식이며 즉시 호출 된 함수 표현식 (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>

산출: 여기에 이미지 설명을 입력하십시오


-1

나는 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 {}

-1

일반적으로 프로그램에서 작성한 직후에는 함수를 호출하지 않습니다. 매우 간단한 용어로, 함수 생성 후 바로 함수를 호출 할 때 IIFE라고합니다.


-1

일반적으로 JavaScript 코드는 응용 프로그램에서 전체 범위를 갖습니다. 전역 변수를 선언하면 개발의 다른 영역에서 다른 목적으로 동일한 복제 변수를 사용할 가능성이 있습니다. 이 중복으로 인해 약간의 오류가 발생할 수 있습니다. 따라서 함수 expression을 즉시 호출하여이 전역 변수를 피할 수 있습니다.이 표현식은 자체 실행 식입니다 .IIFE 내부에서 코드를 만들 때 표현식 전역 변수는 로컬 범위 및 로컬 변수와 같습니다.

IIFE 를 만들 수있는 두 가지 방법

(function () {
    "use strict";
    var app = angular.module("myModule", []);
}());

또는

(function () {
    "use strict";
    var app = angular.module("myModule", []);
})();

위의 코드 스 니펫에서 " var app "은 이제 지역 변수입니다.

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.