JS

1. 선언
   1. let 변수명 = 데이터
   2. let 배열명 = [ ]
   3. function 함수명(인수){ }
2. 호출
   1. console.log(변수명)
   2. console.log(배열명) ; console.log(배열명[인덱스])
   3. console.log(함수명(인수))

지역변수

• 선언된 지역{ } 밖으로 못나감/안으로 들어갈 수 있음

let 경기도 = "강호동"
if(조건) { let 안산 = "유재석"}
/*
	안산이라는 지역밖으로 나가지 못한다. (즉, 안산은 경기도 쪽으로 나갈 수 없다.)
	경기도는 지역 안으로 갈 수 있다. (즉, 경기도는 안산이 있는 if문 몸쪽으로 들어갈 수 있다.)
*/

함수

• 함 : 상자 / 수 : 숫자/코드
  • 상자 안에 들어있는 수/코드 → 상자 미리 넣어둔 수/코드
    • → 미리 정의된 수

1. 역할

   1. 재활용성 : 미리 정의된 코드를 반복적으로 사용

   2. 메모리 효율성 : { } 에서만 메모리 할당

      ‘{’;시작되면 실행 필요한 메모리 할당

      ‘}’ 끝나면 함수 내 사용된 메모리 초기화 → 즉 사라지기 전에 남겨야함. ⇒ 인수와 반환 값!

   3. 인수와 반환 값

      1. 인수 [매개변수 : 정해져있지 않은 수 ] : 함수 안으로 들어가는 수 [함수를 호출했던 위치에서]
      2. 반환 : 함수 밖으로 나가는 수[ 함수를 호출했던 곳으로]

         1. 정의 : function 더하기함수(x, y) {return x + y}

         2. 호출 : 더하기 함수(3, 2)

         3. 호출 후 반환 값 : let 결과 = 더하기 함수(3, 2)

            

         4. 함수를 만들어야 하는 경우의 수

            1. 코드를 작성하는데 반복적인 코드 있을 경우
            2. 여러 개발자들이 같이 사용해야하는 경우 [ex. console.log]
            3. 메모리를 영구 저장없이 잠시 사용 후 메모리 초기화 해야 되는 경우

         5. 형태

            /* 1. 인수 O 반환 O 인 함수*/
            //정의
            function 함수1(x,y){
            	return x+y;
            }
            //호출
            let 결과1 = 함수1(3,5)
            
            /*2. 인수 O 반환 X 인 함수*/
            //정의
            function 함수2(x,y){
            	x + y;
            }
            //호출
            함수2(3, 5)
            
            /*3. 인수 X 반환 O 인 함수*/
            //정의
            function 함수3(){
            	return value;
            }
            //호출
            let 결과3 = 함수3();
            
            /*4. 인수 X 반환 X 인 함수*/
            //정의
            function 함수4(){
            	
            }
            //호출
            함수4()
            

            /*
            	function : 함수 선언시 사용되는 키워드
            		함수1 : 함수이름[식별자] 동일한 파일 내에서는 중복 이름 불가능
            		() : 인수 정의히는 곳
            		{} : 함수가 호출되면 실행디는 구역
            
            */
            
            // 1. 인수X 반환X 함수
            function 함수1(){ // f s 
            
            	alert('함수1 실행 됨')
            } // f e 
            
            // 1. 함수 호출 
            함수1()
            
            // 2. 인수O 반환O 함수 
            function 함수2( x , y  ){ // f s
            	// ( x , y ) : 해당 함수를 호출시 인수[ x와 y : 이름 아무거나 ] 2개를 받는 함수
            	alert('함수2 실행 됨')
            	return x + y;
            } // f e 
            
            let result = 함수2( 3 , 5 )	// 반환[return] 값을 변수에 저장
            alert( '함수2 실행후 보내준 값 :' + result )
            
            // 3. 인수O 반환X 함수 
            function 함수3( x , y , z ){ // f s
            	let result = x +  y + z
            	alert( '함수3 실행 됨 : ' + result )
            } // f e 
            함수3( 3 , 5 , 7 )
            
            // 4. 인수X 반환O 함수 
            function 함수4( ){ // f s
            	let result = 3 + 5 + 8
            	return result;
            } // f e 
            
            let result2 = 함수4()
            alert( '함수4 실행후 보내준 값 :' + result2 )
            

배열명.indexOf(찾을 데이터) : 찾을 데이터의 인덱스 반환 → 있으면 인덱스 반환 /없으면 -1

배열명.includes(찾을 데이터) : 찾을 데이터의 존재 여부 → 있으면 true /없으면 false