반응형

Array.of

무언가를 array로 만들고 싶을 때 사용한다.

const a = ["a","b","c","d"]

const a = Array.of("a","b","c","d")

 

Array.from

array lik object를 array로 만들어준다. 예를들어

//html
<div>
 <button class=button> iam btn</button>
 <button class=button> iam btn</button>
 <button class=button> iam btn</button>
 <button class=button> iam btn</button>
</div


const buttons = documenet.getElementsByClass("button")

// 이것은 불가능합니다.
buttons.forEach(btn=>{
  btn.addEventListener("click",()=>console.log("HI"))
}

//이것은 가능합니다.
Array.from(buttons).forEach(btn=>{
  btn.addEventListener("click",()=>console.log("HI"))
}

 

Array.find

find를 사용해서 true가 나올시 첫번째 element를 알려준다.

const fruits = ["mangoapple", "grape", "apple", "pineapple", "orange"];

const a = fruits.find((fruit) => fruit.includes("apple"));

console.log(a);


// mangoapple

Array.findIndex

true가 나올 시 해당 첫번째로 true값으로 반환된  인덱스번호를 알려준다. 

const fruits = ["mangoapple", "grape", "apple", "pineapple", "orange"];

const check = () => fruits.findIndex((fruit) => fruit.includes("apple"));

let target = check();
console.log(target);

const oneOfFruit = fruits[target].split("apple")[0];

const apple = "Apple";

fruits[target] = `${oneOfFruit} & ${apple}`;

target = check();

console.log(target); // <= target에 다음 해당 인덱스가 있으면 양수가 나오고 없으면 음수가 나온다.
console.log(fruits);


//["mango & Apple", "grape", "apple", "pineapple", "orange"]

 

Array.fill

const fruits = ["mangoapple", "grape", "apple", "pineapple", "orange"];

const check = () => fruits.findIndex((fruit) => fruit.includes("apple"));

fruits.fill("*".repeat(3), 1, 2);

console.log(fruits);

//) ['mangoapple', '***', 'apple', 'pineapple', 'orange']

 

Array Destructuring

const numbers = ['1','2','3','4','5']

const [one,two,three]=numbers

console.log(one,two,three)

//1,2,3





const numbers = ["1", "2", "3", "4", "5"];

const [one, two, three, six = "6"] = numbers;

console.log(one, two, three, six);

//1,2,3,4





const numbers = ["1", "2", "3"];

const [one, two, three, six = "6"] = numbers;

console.log(one, two, three, six);

//1,2,3,6

 

Renaming

//데이터를 받아왔다고 가정
const setting = {
  color: {
    chose_color: "dark",
  },
};
// 데이터의 이름을 renaming
//let으로도 가능하다.
const {
  color: {chose_color: choseColor = "light"},
} = setting;

// 위와 같다.
// const choseColor = setting.color.chose_color || "light";

console.log(choseColor);

//let으로 할경우
//데이터를 받아왔다고 가정
const settingTwo = {
  color: {
    chose_color: "dark",
  },
};
// 데이터의 이름을 renaming
let choseColorTwo = "blue";
({
  color: {chose_color: choseColorTwo = "light"},
} = settingTwo);

// 위와 같다.
// const choseColorTwo = settingTwo.color.chose_color || "light";

console.log(choseColorTwo);

 

Swapping & Skipping

//Swapping

let tomato = "lemon";
let lemon = "tomato";
//Array destructuring을 사용하여 값을 맞춰준다.
// 바꿀 값을 원래 순에 맞게 첫번째 배열에 넣어준다.
// 바뀌어져야하는 변수를 바꿀 값 배열에 맞게 순서대로 적는다.
//";"을 꼭 사용해서 라인을 분간 시켜준다.
[lemon, tomato] = [tomato, lemon];

console.log(tomato);
console.log(lemon);

//Skipping
const days = ["mon", "tue", "wed", "thu", "fri"];

const [, , , thu, fri] = days;
console.log(thu, fri);
728x90

'CODING PRACTICE > JavaScript & ES6' 카테고리의 다른 글

ES6__004(Promises / async &. await)  (0) 2023.12.21
ES6__003(Spread / Rest / for of Loop)  (0) 2023.12.20
ES6 __001 (Arrow Fuctions , String)  (1) 2023.11.21
Pagination 공식  (0) 2023.08.10
2023/04/11__JavaScript__05  (0) 2023.04.13
반응형

"this" keyword in Arrow Functions

this 키워드를 사용해야하는 경우를  arrow function 제외하고 사용할 수 있다.

const button = document.querySelector("button");

button.addEventListener("click", function () {
  console.log(this);
  console.log("clicked");
});

 

arrow function을 사용해서 this를 불러내면 window object들을 불러낼것이다.

const hi = {
  hi: "hoho",
  bye: false,
  age: 2,
  addMeet() {
    this.age++;
  },
};
console.log(hi);
hi.addMeet();
console.log(hi);

hi.addMeet();
hi.addMeet();
hi.addMeet();
hi.addMeet();
hi.addMeet();

console.log(hi);

 

Arrow Function에서의 return

const email = ["korea@korea.com", "naver@naver.com", "hoho@hoho.com"];
const haha = email.map((e, index) => {
  return {username: e.split("@")[0], index};
});
console.log(haha);


const email = ["korea@korea.com", "naver@naver.com", "hoho@hoho.com"];
const haha = email.map((e, index) => ({username: e.split("@")[0], index}));
console.log(haha);

 

Funtion에서의 기본값

function sayHello(name = "choi") {
  return "Hello " + name;
}
console.log(sayHello());
console.log(sayHello("jaja"));

const helloMechine = (name = "hihi") => {
  return "Hello " + name;
};
console.log(helloMechine());
console.log(helloMechine("chimp"));

 

Template Literals

const wrapper = document.querySelector(".wrapper");

// const addWelcome = () => {
//   const div = document.createElement("div");
//   const h1 = document.createElement("h1");
//   h1.innerText = "Hello";
//   h1.className = "hiTitle";
//   div.append(h1);
//   wrapper.appendChild(div);
// };



const addWelcome = () => {
  const div = `
    <div>
        <h1 class="hiTitle">Hello</h1>
    </div>
  `;
  wrapper.innerHTML = div;
};

addWelcome();

둘다 같은 결과를 내며 꼭 백틱(  )을 사용해야한다.

const wrapper = document.querySelector(".wrapper");

const laugh = ["haha", "hoho", "hehe", "jaja", "hihi"];

const list = ` 
<h1>Laugh List</h1>
<ul>
${laugh.map((item) => `<li>${item}</li>`).join("")}
</ul>
`;

wrapper.innerHTML = list;

 

const wrapper = document.querySelector(".wrapper");
const cssIncome = (css) => {
  console.log(css);
};

cssIncome(`border-radius:10px;color:blue;`);
cssIncome`border-radius:10px;color:blue;`;

// const styled = (newEle) => {
//     const el = document.createElement(newEle);
//     return el;
// };
// const title = styled("h1")`border-radius:10px;color:blue;`; 이렇게 하면 에러가 난다. 에러가 나는 이유는 funtion을 두번 호출했다는 의미이다.

const styled = (newEle) => {
  const el = document.createElement(newEle);
  return (args) => {
    console.log(args[0]);
    const styled = args[0];
    el.style = styled;
    return el;
  };
};
const title = styled("h1")`
  border-radius: 10px;
  color: blue;
`;
const span = styled("span")`
  font-size: 25px;
  color: red;
`;

title.innerText = "wow";
span.innerText = "suprised!!";

wrapper.append(title, span);

 

repeat / includes / startWithin / endWithin / forEach / map / replace ...

728x90

'CODING PRACTICE > JavaScript & ES6' 카테고리의 다른 글

ES6__003(Spread / Rest / for of Loop)  (0) 2023.12.20
ES6__002(Array & Destructuring)  (0) 2023.12.01
Pagination 공식  (0) 2023.08.10
2023/04/11__JavaScript__05  (0) 2023.04.13
2023/04/10__JavaScript__04  (0) 2023.04.12
반응형


// 전체 데이터 가져오기
total = '';

// paging : 한 페이지 당 보여질 목록 수
list_num = 5;

// paging : 한 블럭 당 페이지 수
page_num = 3;

// paging : 현재 페이지
page = (page)? page : 1;

// paging : 전체 페이지 수 = 전체 데이터 / 페이지 당 목록 수
total_page = ceil(total / list_num);


// paging : 전체 블럭 수 = 전체 페이지 수 / 블럭 당 페이지 수
total_block = ceil(total_page / page_num);

// paging : 현재 블럭 번호 = 현재 페이지 번호 / 블럭 당 페이지 수
now_block = ceil(page / page_num);

// paging : 블럭 당 시작 페이지 번호 = (해당 글의 블럭 번호 - 1) * 블럭 당 페이지 수 + 1
s_pageNum = (now_block - 1) * page_num + 1;
if(s_pageNum <= 0){
s_pageNum = 1;
};

// paging : 블럭 당 마지막 페이지 번호 = 현재 블럭 번호 * 블럭 당 페이지 수
e_pageNum = now_block * page_num;

// 블럭 당 마지막 페이지 번호가 전체 페이지 수를 넘지 않도록
if(e_pageNum > total_page){
e_pageNum = total_page;
};

........................
/** pager **/
// paging : 해당 페이지의 글 시작 번호 = (현재 페이지 번호 - 1) * 페이지 당 보여질 목록 수
d_start = (page - 1) * list_num;

// paging : 해당 페이지의 글 마지막 번호 = 현재 페이지 번호 * 페이지 당 보여질 목록 수
d_end = (page - 1) * list_num;
if(d_end > total){
d_end = total;
};

// 글 출력
for(print_data=start; print_data < d_end; print_data++){
 //  글 출력

// pager : 페이지 번호 출력
for(print_page = s_pageNum;  print_page <= e_pageNum; print_page++){
  // 페이지 번호 출력
};

}

728x90

'CODING PRACTICE > JavaScript & ES6' 카테고리의 다른 글

ES6__002(Array & Destructuring)  (0) 2023.12.01
ES6 __001 (Arrow Fuctions , String)  (1) 2023.11.21
2023/04/11__JavaScript__05  (0) 2023.04.13
2023/04/10__JavaScript__04  (0) 2023.04.12
2023/04/07__JavaScript__03  (0) 2023.04.11
반응형

* class

1. JavaScript 객체용 템플릿

2. 객체가 아닌 객체에 대한 템플릿

 

* 문법

1. class 키워드 사용

2. constructor() 메소드를 반드시 추가

3. constructor() : 이름이 지정되어 있는 메소드

# EX)
class ClassName{
 constructor(){...}
 }
 
# EX)
class Car {
 constructor(name, year){
  this.name = name;
  this.year = year;
  }
 }

* 클래스 사용

1. 클래스가 있으면 클래스를 사용하여 객체 생성가능

2. 생성자 메서드는 새 객체가 생성될 때 자동으로 호출

# Form
const myCar1 = new Car("Ford",2014);
const myCar2 = new Car("Audi",2014);

#EX)
<p id="demo"></p>

<script>

class car{
 constructor(name,year){
  this.name = name;
  this.year = year;
 }
}

const myCar1 = new Car("Ford",2014);
const myCar2 = new Car("Audi",2014);

document.getElementById("demo").innerHTML = 
myCar1.name + " " + myCar2.name;

</script>

* 생성자 방법

1. 정확한 이름 "constructor" 필수

2. 새로운 객체가 생성되면 자동으로 실행

3. 객체 속성을 초기화하는 데 사용

4. 생성자 메서드를 정의하지 않으면 자동으로 빈생성자 메서드 추가

 

* 클래스 방식에서 메서드 사용 방법

1. 객체 메서드와 동일한 구문으로 생성

2. class 키워드 사용하여 생성

3. constructor() 반드시 추가

 

그런 다음 여러 방법을 추가합니다.

# syntex

class ClassName{
 constructor(){...}
 method_1(){...}
 method_2(){...}
 method_3(){...}
}

# EX) Car age를 반환하는 "age" 클래스 메서드 생성
class Car {
 constructor(name,year){
  this.name = name;
  this.year = year;
 }
 age() {
  const date = new Date();
  return date.getFullYear() - this.year;
  }
 }
 
 const myCar = new Car("Ford",2014);
 document.getElementById("demo").innerHTML = 
 "My car is " + myCar.age() + " years old.";
 
 //------------------------------------------
 
 # EX) 클래스 메소드 매개변수 전달
class Car {
 constructor(name,year){
  this.name = name;
  this.year = year;
 }
 age() {
  return x - this.year;
  }
 }
 
 const date = new Date();
 let year = date.getFullYear();
 
 const myCar = new Car("Ford",2014);
 document.getElementById("demo").innerHTML = 
 "My car is " + myCar.age(year) + " years old.";

* strict mode(엄격모드)

1. 클래스의 구문은 "엄격 모드"로 작성

2. "strict mode" 규칙을 따르지 않으면 오류 발생

 

#EX) : "엄격 모드"에서 변수를 선언하지 않고 사용하면 오류 발생
class Car{
 constructor(naem,year){
  this.name=name;
  this.year=year;
  }
 age(){
  // date = new Date(); //오류발생
  const date = new Date(); //실행
  return date.getFullYear() - this.year;
  }
 }
 
 const myCar = new Car("Ford",2014);
 document.getElementById("demo").innerHTML = 
 "My car is " + myCar.age() + " years old.";

* 클래스 상속

1. extends 키워드 사용

2. 클래스 상속으로 생성된 클래스는 다른 클래스의 모든 메서드를 상속

#EX) : "Car" 클래스에서 메서드를 상속할 "Model"이라는 클래스 생성
class Car{
 constructor(brand) {
  this.carname = brand;
 }
 present() {
  return ` I have a ${this.carname}`;
  }
};

class Model extends Car {
 constructor(brand,mod) {
  super(brand);
  this.model = mod;
 }
 show() {
  return this.present() + ', it is a ' + this.model;
 }
};

let myCar = new Model("Ford", "Mustang");
document.getElementById("demo").innerHTML = myCar.show();

3. super() 메서드는 부모 클래스 참조

4. 생성자 메서드에서 super() 메서드를 호출하여 부모의 생성자 메서드를 호출하고 부모의 속성 및 메서드에 대한 액세스 권한 획득

 

#메모

1. 상속은 코드 재사용에 유용

2. 새 클래스를 만들 때 기존 클래스의 속성과 메서드 재사용

 

* 게터와 세터

1. 클래스를 사용하면 getter와 setter 사용 가능

2. 값을 반환하기 전, 또는 설정하기 전에 값으로 특별한 작업을 수행하려는 경우 속성에 getter 및 setter를 사용 가능

3. get, set 키워드 사용 

# EX) : "carname" 속성에 대한 getter 및 setter 생성

class Car{
 constructor(brand) {
  this.carname = brand;
 }
 get cnam() {
  return this.carname;
 }
 set cnam(x) {
  this.carname) = x;
  }
 }

4. getter가 메서드인 경우에도 속성값을 가져오려는 경우 괄호 사용 안함

5. getter/setter 메서드의 이름은 속성 이름과 같을 수 없음 / getter/setter를 실제 속성과 구분하기 위해 속성 이름 앞에 밑줄 문자 사용

# EX) : 밑줄 문자를 사용하여 getter/setter를 실제 속성과 구분
class Car {
 constructor(brand){
  this._carname = brand;
 }
 get carname() {
  return this._carname;
 }
 set carname(x){
  this._carname = x;
 }
}

const myCar = new Car("Ford");
document.innerHTML  = myCar.carname

6. setter를 사용하려면 괄호 없이 속성 값을 설정할 때와 동일한 구문 사용

# EX) : setter를 사용하여 carname을  "Volvo"로 변경
class Car {
 constructor(brand){
  this._carname = brand;
 }
 get carname() {
  return this._carname;
 }
 set carname(x){
  this._carname = x;
 }
}

const myCar = new Car("Ford")
myCar.carname = "Volvo";
document.getElementById("demo").innerHTML = myCar.carname;

* Hoisting

1. 함수 및 기타 JavaScript 선언과 달리 클래스 선언은 호이스팅되지 않음

2. 클래스 선언 후 사용 가능

EX
// ReferenceError : class 생성 전 실행
myCar = new Car("Ford") will raise an error.

class Car {
 constructor(brand){
  this.carname = brand;
 }
}

// 클래스 실행
const myCar = new Car("Ford")

* 정적 메소드

1. 정적 클라스 메서드는 클래스 자체에 정의

2. static 객체에서 메서드를 호출할 수 없으며 객체 클래스에서만 호출가능

# 예
class Car{
 constructor(name){
  this.name=name;
 }
 static hello() {
  return "Hello!!";
 }
}

const myCar = new Car("Ford");

//Car 클래스 내부의 'hello()' 호출
document.getElementById("demo").innerHTML = Car.hello();

# ex) : 메서드 내에서 myCar 객체를 사용 -> static 매개 변수로 전달
class Car {
 constructor(name) {
  this.name = name;
 }
 static hello(x) {
  return "Hello " + x.name;
 }
}

const myCar = new Car("Ford")
document.getElementById("demo").innerHTML = Car.hello(myCar);
728x90

'CODING PRACTICE > JavaScript & ES6' 카테고리의 다른 글

ES6 __001 (Arrow Fuctions , String)  (1) 2023.11.21
Pagination 공식  (0) 2023.08.10
2023/04/10__JavaScript__04  (0) 2023.04.12
2023/04/07__JavaScript__03  (0) 2023.04.11
2023/04/04~06__Javascript__02  (0) 2023.04.07
반응형

* 콜백 함수

1. 다른 함수에 인수로 전달되는 함수

2. 함수가 완료된 후 콜백 함수 실행

 

* 일반 함수 호출

#EX)

function myFirst(){
myDisplayer("Hello")
}

function mySecond() {
myDisplayer("Good Day")
}

myFirst();
mySecond(); -- "Good Day"

mySecond();
myFirst(); -- "Hello"

* 시퀀스 제어

1. 함수를 실행할 시점을 구체적으로 정의

#EX)
function myDisplayer(some){
document.getElementById("demo").innerHTML = some;
}

// 1) 계산기 함수(myCalculator)를 호출하여 결과 저장 후
// 2) 디스플레이 함수(myDisplayer)를 호출하여 결과 출력
=> 두 개의 함수 호출 필요
function myCalculator(num1, num2){
let sum = num1 + num2;
return sum;
}

let result = myCalculator(5,5)
myDisplayer(result);
//----------------------------------------------------

// 1) 계산기 함수(myCalculator)를 호출하여 결과 저장 후
// 2) 계산기 함수(myCalculator)에서 디스플레이 함수 (myDisplayer)호출
=> 계산기 기능이 결과를 표시하지 못하게 할 수 없음
function myCalculator(num1,num2){
let sum = num1 + num2;
myDisplayer(sum);
}
myCalculator(5,5);

## 콜백 함수 활용

// 1) 계산기 함수 (myCallback)를 호출하고 계산이 완료된 후
// 2) 계산기 함수가 디스플레이 함수(myDisplayer)호출 (콜백)

function myDisplayer(some){
  document.getElementById("demo").innerHTML = some;
}

function myCalculator(num1,num2,myCallback){
  let sum = num1 + num2;
  myCallback();
}

myCalculator(5,5,myDisplayer);

// 3)함수를 인수로 전달할 때 괄호는 반드시 생략
myCalculator(5,5,myDisplayer); // OK
myCalculator(5,5,myDisplayer()); // NEVER DO THIS

* 비동기

1. 다른 함수와 병렬로 실행되는 함수

#EX) setTimeout()
setTimeout(myFunction, 3000)

function myFunction(){
  document.getElementById("demo").innerHTML = "Have a good day!!";
  
// 1) setTimeout 함수가 실행된 후 myFunction 함수 실행
// 2) 호출할 함수가 많아지면 코드량 증가(콜백지옥)

* 콜백 대안

1. 비동기 프로그래밍을 통해 장기 실행 작업을 병렬로 실행 가능

2. 비동기 프로그램은 작성하기 어렵고 디버깅하기 어려움

3. 최신 비동기 JavaScript 메서드는 콜백 대신 Promise 사용

 

* Promise 객체

1. Promise 객체에는 생성 코드와 소비 코드에 대한 호출 모두 포함

# 구문
let myPromise = new Promise(function(myResolve,myReject){
myResolve(); // 함수실행 성공시 수행할 코드
myReject(); // 함수 실행 실패시 수행할 코드
});

// "Counsuming Code"(Must wait for a fulfilled Promise)
myPromise.then(
function(value){/*code if successfull */},
function(error){/* code if some error */}
)

* Promise 개체 속성

1. Promise 객체는 state 및 result라는 두 가지 속성을 지원

2. state & result

- pending(보류 중) : undefined

- fulfilled(이행 됨) : 결과값 반환

- rejected(거부 됨) : 에러 반환

 

* 사용 방법

1. Promise.then()은 성공에 대한 콜백과 실패에 대한 콜백 두 가지 인수 사용

2. 둘 다 선택 사항이므로 성공 또는 실패에 대한 콜백 추가 가능

myPromise.then(
function(value) { /* code if successful*/ }
function(error) { /* code if some error*/ }
);

// ---------------------------------------
#EX)
function myDisplayer(some){
  document.getElementById("demo").innerHTML = some;
}

let myPromise = new Promise(function(myResolve, myReject){
let x =0;

// The producing code (this may take some time)

if(x==0){
  myResolve("OK")
 } else {
  myReject("Error");
  }
 });
 
 myPromise.then(
   function(value) {myDisplayer(value);},
   function(error) {myDisplayer(error);}
);

* 콜백 & promise

# A1 .  콜백
setTImeout(function(){myFunction("good day!!");},3000};

function myFunction(value){
  document.getElementById("demo").innerHTML = value;
)

# A2. promise
let myPromise = new Promise(function(myResolve,myReject){
  setTimeout(function() {myResolve("Good day!!");},3000);
});

myPromise.then(function(value){
  document.getElementById("demo").innerHTML = value;
});

# B1. 콜백
<p id = "demo"></p>
<script>
function myDisplayer(some){
  document.getElementById("demo").innerHTML = some ;
}

function getFile(myCallback) {
  let req = new XMLHttpRequest();
  req.onload = function() {
    if (req.status == 200) {
      myCallback(this.responesText);
    } else {
      myCallback("Error: " + req.status);
    }
  }
  
  req.open('GET', "mycar.html);
  req.send();
let myPromise = new Promise(function(myResolve, myReject){
 let req = new XMLHttpRequest();
 req.open('GET', "mycar.html");
 req.onload = function() {
 if(req.status == 200){
  myResolvee(req.respones);
 } else {
  myReject("File not Found");
 }
};
req.send();
});

myPromise.then(
 function(value) { myDisplayer(value); },
 function(error) { myDisplayer(error) }
);

* async & await

1. async와 await는 promise를 좀 더 편하게 사용

2. async는 함수가 Promise를 반환하도록 함

3. await는 함수가 Promise를 기다리게 함

 

* async

1. 함수가 promise를 반환

2. promise가 아닌 값을 반환하더라도

이행 상태의 프로미스(resolved promise)로 값을 감싸 이행된 프로미스 반환

# EX)
//1)
function myFunction(){
  return Promise.resolve("Hello")
}

//2) async
async function myFunction(){
  return "Hello";
}

myFunction().then(
  function(value) {myDisplayer(value);},
  function(error) {myDisplayer(error);},
);

//2-1) 오류가 없는 문장이므로 error 구문 삭제 가능
async function myFunction(){
  return "Hello";
}

* await

1. 함수가 실행을 일시 중지하고 해결괸 약속을 기다리도록 함

2. async 함수 내에서만 사용 가능

let value = await promise;

# EX) : 기본구문
async function myDisply() {
 let myPromise = new Promise(function(resolve, reject) {
  resolve("Good day");
 });
 document.getElementById("demo").innerHTML = awati myPromise;
}

myDisplay();

// 1) 두 인수(resolve, reject)는 JavaScript에 의해 미리 정의됨
// 2) 직접 작성하지 않지만 excutor 함수가 준비되면 인수 중 하나 호출
// 3) reject가 반드시 필요하지는 않음

* class

1. JavaScript 객체용 템플릿

2. 객체가 아닌 객체에 대한 템플릿

728x90

'CODING PRACTICE > JavaScript & ES6' 카테고리의 다른 글

Pagination 공식  (0) 2023.08.10
2023/04/11__JavaScript__05  (0) 2023.04.13
2023/04/07__JavaScript__03  (0) 2023.04.11
2023/04/04~06__Javascript__02  (0) 2023.04.07
2023/04/03__JavaScript__01  (0) 2023.04.06
반응형

** 객체(object) **

1. 여러 개의 값을 가지는 자료구조

2. 값은 이름: "값" 쌍으로 기록

3. 일반적으로 const 키워드로 선언

 

* 객체 정의

1. 객체 리터럴을 사용하여 정의

const person = {firstName="John", lastName:"Doe", age:50, eyeColor:"blue"};

2. 공백, 줄바꿈 무관

3. 여러 줄에 걸쳐 객체 정의 가능

const person = {
firstName: "John",
lastName: "Doe",
age:50,
eyeColor:"blue"
};

* 객체 생성자

1. 생성자 함수의 이름 첫 글자는 가급적 대문자 지정

# EX
function Person(first, last, age, eye){
this.firtName = first;
this.lastName = last;
this.age = age;
this.eye = eye;
}

const myFather = new Person("John", "Deo", 50, "blue");
const myMother = new Person("Sally, "Rally", 48, "green);

document.getElementById("demo").innerHTML = "My father is " + myFather.age + ".";

2. 프로토타입 상속

Person.prototype.nationality = "English";
document.getElementById("demo").innerHTML = "The nationality of my father is " + myFather.nationality;

 

3.prototype 속성을 이용한 메서드 추가

const person = {firstName="John", lastName:"Doe", age:50, eyeColor:"blue"};

Person.prototype.name = fuction(){
return this.firstName + " " + this.lastName;
};

person.name()

/// John Doe

 

* 객체 속성

1. 이름 : 값 의 쌍

 

*개체 속성에 액세스

1. objectName.propertyName

2. objectName.["propertyName "]

 

* 속성 추가

1. 단순히 값을 지정하여 기존 개체에 새 속성 추가

# EX
person.nationality = "English";
||

// const person = {nationality="English"}

* 속성 삭제

1. delete 키워드 : 속성과 값 모두 삭제

# EX
const person = {
firstName: "John",
lastName: "Doe",
age:50,
eyeColor:"blue"
};

delete person.age;
또는
delete person["age"]

* 중첩 개체 엑세스

1. 개체의 값에 다른 객체 사용

# EX
myObj = {
 name:"John",
 age:30,
 cars:{
  car1:"Ford",
  car2:"BMW",
  car3:"Fiat"
  }
}

2. 점(.) 표기법 또는 대괄호 표기법을 사용하여 중첩된 객체에 액세스

# EX

- myObj.cars.car2;
- myObj.cars["car2"];
- myObj["cars"]["car2"];
- let p1 = "cars";
  let p2 = "car2";
  myObj[p1][p2];

* 객체 메서드

1. 객체에 대해 수행할 수 있는 작업

2. 함수정의로 속성에 저장

const person = {
 firstName: "John",
 lastName: "Doe",
 id: 5566,
 fullName: function(){
 	return this.firstName + " " + this.lastName;
 }
};

* 객체 메서드 사용

1. objectName.methodName()

# EX
name = person.fullName();

2. () 괄호 없이 메서드에 액세스하면 함수 정의 반환

# EX
name = person.fullName;

* 객체 반복(for .. in)

const person = {
  fname:"John",
  lname:"Doe",
  age:25
  };
  
for (let x in person) {
  txt += person[x];
}

1. x는 속성 변환

2. 속성값 반환 : 변수명[객체를 담은 변수]

 

* 중첩 배열 및 객체 반복

1. 객체의 값은 배열이 될 수 있고 배열의 값은 객체가 될 수 있음

#EX
const myObj = {
  name: "Jonh",
  age: 30,
  cars: [ 
    {name:"Ford", models:["Fiesta", "Focus", "Mustang"]},
    {name:"BMW", models:["320", "X3", "X5"]},
    {name:"Fiat", models:["500", "Panda"]},
  ]
}

for (let i in myObj.cars) {
  x += "<h1>" + myObjs.cars[i].name + "</h1>";
  for (let j in myObjs.cars[i].models) {
  x += myObj.cars[i].models[j]
  }
}

* JSON.stringify() ( <--> JSON.parse())

1. JavaScript 함수를 사용하여 모든 JavaScript 객체를 문자열로 변환

# EX
const person = {
  name:"John",
  age:30,
  city:"New York"
};

let myString = JSON.stringify(person);

# Result : JSON 표기법(문자열)
{"이름":"존","나이":50, "도시":"뉴욕"}

* 객체 접근자

1. get : 객체 속성값 가져오기

#EX)

const person = {
  firstName: "John",
  lastName: "Doe",
  language: "en",
  get lang() {
    return this.languasge;
  }
};

document.getElementById("demo").innerHTML = person.lang;

2. set : 객체 속성값 변경(정의)하기

const person = {
  firstName: "John",
  lastName: "Doe",
  language: "",
  set lang(lang) {
    return this.languasge;
  }
};

person.lang = "en";
document.getElementById("demo").innerHTML = person.language;

3. 함수방식과 속성 방식

1. fullName : function() { } - 함수 방식

- person.fullName()

2. get fullName() { } - 메소드 방식

- person.fullName

 

* Javascript 문자열

1. 텍스트를 저장하고 조작하기 위한 자료형

2. 따옴표 안에 쓰여진 0개 이상의 문자

#EX)
let text = "John Doe";
let text = 'John Doe';

3. 문자열을 둘러싼 따옴표와 일치하지 않으면 문자열 내에서 따옴표 사용가능

#EX)
let answer1 = "It's alright";
let answer2 = "He is called `Johnny`";
let answer3 = 'He is called "Johnny"';

* length : 문자열 길이

1. 문자열의 길이 반환

#EX)
let text = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
let length = text.length; // 26

* 이스케이프 문자

1. 백슬래시( \ ) 사용

2. 특수 문자를 문자열 문자로 변환

#EX)
--------------------------------
Code | Result | Description
--------------------------------
₩'   | '      | Single quote
₩"   |  "     | Double quote
₩₩   | ₩      | Backslash

3. ₩" 시퀀스 : 문자열에 큰 따옴표 삽입

#EX)
let text = "We are the so-called ₩"Vikings₩" from the north.";

4. ₩' 시퀀스 : 문자열에 작은 따옴표 삽입

#EX)
let text = 'It₩'s alright';

5. ₩₩ 시퀀스 : 문자열에 백슬래시 삽입

#EX)
let text = 'The character ₩₩ is called backslash.";

6. 기타 이스케이프 시퀀스

---------------------------------
Code		Result
---------------------------------
₩b			Backspace
₩f			Form Feed
₩n			New Line
₩r			Carriage Return
₩t			Horizontal Tabulator
₩v			Vertical Tabulator

- 이 6개의 이스케이프 문자는 타자기, 텔레타이프 및 팩스 기계를 제어하도록 설계

- HTML에서는 적용되지 않음

 

* 긴 코드 줄 끊기

1. 가독성을 위해 긴 코드 행을 여러 행으로 분리

2. 중단하기에 가장 좋은 위치는 연산자 다음

#EX)
document.getElementById("demo").innerHTML = 
"Hello Dolly!!";

3. 단일 백슬래시를 사용하여 텍스트 문자열 내의 코드 줄 분리

#EX)
document.getElementById("demo").innerHTML = "Hello ₩
Dolly!!";

// 1) 일부 브라우저는 문자 뒤에 공백 허용 않음

4. 문자열 추가

#EX)
document.getElementById("demo").innerHTML = "Hello +
"Dolly!";

5. 백슬래시로 코드 줄 분리

#EX)
document.getElementById("demo").innerHTML = ₩
"Hello Dolly!!";

* 문자열 부분 추출

1. slice(start, end)

2. substring(strat, end)

3. substr(start, length)

 

* slice()

1. 문자열의 일부를 추출하고 추출된 부분을 새 문자열로 반화

2. 시작위치, 종료위치(끝은 포함되지 않음)의 2개 매개변수 사용

#EX) : 위치 7에서 위치 13 전 까지 문자열의 일부 추출
let text = "APPLE, BANABA, KIWI";
let part = text.slice(7,13);

# 메모

1. JavaScript는 0부터 위치를 계산

0: 첫 번째 위치

1: 두 번째 위치

# EX) : 두 번째 매개변수를 생략하면 문자열의 나머지 부분 추출
let text = "APPLE, BANAN, KIWI";
let part = text.slice(7);

# EX) : 매개변수가 음수이면 문자열의 끝부터 추출
let text = "APPLE, BANAN, KIWI";
let part = text.slice(-12);

# EX) : 매개변수가 음수이면 문자열의 끝부터 추출
let text = "APPLE, BANAN, KIWI";
let part = text.slice(-12, -6);

* substring()

1. slice()와 유사

2. ()보다 작은 시작 및 끝 값은 에서 0으로 처리

#EX)
let str = "APPLE, BANANA, KIWI";
let part = srt.substring(7,13);

#EX) : 두번째 매개변수를 생략하면 나머지 문자열 반환
let str = "APPLE, BANANA, KIWI";
let part = srt.substring(7,13);

* substr()

1. slice()와 유사

2. 두 번째 매개변수가 추출된 부분의 길이를 지정

#EX)
let str = "APPLE, BANAN, KIWI";
let part = str.substr(7,6);

#EX) : 두 번째 매개변수를 생략하면 나머지 문자열 반환
let str = "APPLE, BANAN, KIWI";
let part = str.substr(7);

#EX) : 첫 번째 매개변수가 음수이면 문자열의 끝부터 계산
let str = "APPLE, BANAN, KIWI";
let part = str.substr(-4);

*replace()

1. 지정된 값을 문자열의 다른 값으로 변경

#EX)
let text = "Please visit Microsoft!";
let newText = text.replace("Microsoft", "APPLE");

2.replace()메서드는 호출된 문자열을 변경하지 않고 새 문자열 반환

3.첫 번재 일치 항목만 변경

4. 모든 일치 항목을 바꾸면 /g 플래그가 설정된 정규식 사용

#EX) : 첫 번째 일치 항목만 변경(기본)
let text = "Please visit Microsoft and Microsoft!";
let newText = text.replace("Microsoft", "APPLE");

5. 대/소 문자 구분

#EX)
let text = "Please visit Microsoft!";
let newText = text.replace("MICROSOFT", "APPLE");

6. 대소문자를 구분하지 않으려면 정규 표현식을 /i 플래그 (구별하지 않음) 사용

#EX)
let text = "Please visit Microsoft!";
let newText = text.replace(/MICROSOFT/i, "APPLE");

* replaceAll()

1. 문자열 모두 바꾸기

#EX)
text = text.replaceAll("Cats","Dogs");
text = text.replaceAll("cats","dogs");

2. 바꿀 문자열 대신 정규식 지정 가능

3. 매개변수가 정규식이면 전역 플래그(g) 설정 필수

(TypeError)

#EX)
text = text.replaceAll(/Cats/g,"Dogs");
text = text.replaceAll(/cats/g,"dogs");

* 대/소문자 변환

1. toUpperCase()

2. toLowerCase()

#EX)
let text1 = "Hello World!";
let text2 = text1.toUpperCase();
let text3 = text1.toLowerCase();

* concat()

1. 두 개 이상의 문자열을 결합

#EX)
let text1 = "Hello";
let text2 = "World!";
let text3 = text1.concat(" ", text2)

2. 더하기 연산자 대신 사용 가능

#EX)
text = "Hello" + " " + "World!";
text = "Hello".concat(" ", "World!")

# 메모

1. 모든 문자열 메서드는 원래 문자열을 수정하지 않고 새 문자열을 반환

2. 문자열은 변경할 수 없으며 교체만 가능

 

*trim()

1. 문자열 양쪽의 공백 제거

#EX)
let text1 = "     Hello World!   ";
let text2 = text1.trim();
javascript 문자열 trimStart()

2. trimStart() : 문자열 시작 부분에서만 공백제거

#EX)
let text1 = "     Hello World!   ";
let text2 = text1.trimStart();

3. trimEnd() : 문자열 끝에서만 공백 제거

#EX)
let text1 = "     Hello World!   ";
let text2 = text1.trimEnd();

* padStart(), padEnd()

1. 주어진 길이에  도달할 때까지 다른 문자열로 채우기

2. 문자열의 처음부터 채우기

 

*문자열 문자 추출

1. charAt(position)

2.charCodeAt(position)

3. 속성 액세스 []

728x90

'CODING PRACTICE > JavaScript & ES6' 카테고리의 다른 글

Pagination 공식  (0) 2023.08.10
2023/04/11__JavaScript__05  (0) 2023.04.13
2023/04/10__JavaScript__04  (0) 2023.04.12
2023/04/04~06__Javascript__02  (0) 2023.04.07
2023/04/03__JavaScript__01  (0) 2023.04.06
반응형

2. 다중 반복문

for (시작값, 최종값, 증감식){
	for(시작값, 최종값, 증감식){
    반복할 문장
    }
}

 


** 조건문 **

1. 조건의 결과에 따라 다르게 문장을 실행

2. if문

조건이 참인 경우 다음 문장을 실행

if (A 조건) {
조건이 참인 경우 실행할 코드
} else if(B조건){
A 조건 외의 조건이 참인 경우 실행할 코드
} else {
if와 else if 조건이 참이 아닐 경우 실행할 코드
}

2-1. if문의 다수 사용

- 각각의 조건이 독립적

2-2 중괄호 사용

- 여러 개의 문장을 하나의 조건문에 종속

2-3 if~else // if ~ else if ~ else

- 위 if문 참조

 

3. switch 문

switch(변수){
case "값1" : 변수값이 "값1"인 경우 실행할 문장
	break;
case "값2" : 변수값이 "값1"인 경우 실행할 문장
	break;
case "값3" :
case "값4" :
case "값5" :변수값이 "값1"인 경우 실행할 문장
	break;
default : 변수값이 "값1","값2","값3",이 아닌 경우 실행할 문장
}

** 함수 **

미리 약속되어 있는 명령어

1. 내장 함수 - 만들어져 있는 명령어

2. 사용자 정의 함수 - 만들어서 사용하는 명령어

 

** 내장 함수

1. 대화상자 함수

- alert("문자열") : 메세지 상자

- confirm("문자열") : 확인 / 취소 선택 상자

- prompt("질문메세지", "초기메세지") : 사용자 입력 상자

 

** 사용자 정의 함수 **

1. 사용자가 임의로 생성한 함수

2. 선언문 : function

function 함수명 (매개변수, 매개변수 ...){
실행문...
실행문...
.
.
}

3. 호출 시에만 실행

4. 사용자 정의 함수 호출방법

- 단독 실행

ex) functionName ();

 

- 변수에 의한 실행

ex) const i = functionName ();

 

- 다른 함수에 의한 실행

ex) setTimeout(functionName, 5000)

 

- 이벤트에 의한 실행(****)

ex) <body onload = "functionName()"

 

5. 함수명 규칙 : 변수명 규칙과 동일

 

** 이벤트 **

1. 언제

2. 이벤트 : 상황 ,~~하다

3. 이벤트 핸들러 : 이벤트 사용, ~~ 했을 때

                            이벤트 앞에 on 추가

이벤트 이벤트 핸들러
load onload
unload onunload
mouseover onmouseover
mouseout onmouseout
focus onfocus
blur onblur
click onclick
mousedown onmousedown
mouseup onmouseup

** 화살표(=> ,ES6) 함수 **

1. 뚱뚜한 화살표(=>,arrow function)를 사용하여 함수 선언

2.ES5 일반함수 선언

function(매개변수){

실행할 문장

}

3. 화살표함수

(매겨변수)=>{

실행할 문장

}

4. 매개변수가 하나인 경우 () 생략 가능

매개변수 => {

실행할 문장

}

5. 매개변수가 없는 경우 빈 괄호 사용

0 => {

실행할 문장

}

6. 문법은 간단해지지만 공통된 규칙이나 일반적인 사용방법이 필요할 수 있음

 

** DOM(Document Object Model) 방식 **

- html 요소에 접근하는 표준화된 방식

- 기존 name 속성과 태그별 접근 방식에서 벗어나 오브젝트의 종류에 상관없이 id속성을 사용하여 요소에 접근하는 방식

* getElementById("요소") 객체의 생성

 

웹 페이지 개발 방식

- 분리해서 개발

1. 구조(Structure) - HTML

2.표현(Presentation) - CSS

3.동작(Behavior) - JavaScript

 

** 이벤트 핸들러(이벤트 리스너, 이벤트 처리기)

1. 이벤트가 발생했을 때 그 처리를 담당하는 함수

2. 지정된 타입의 이벤트가 특정 요소에서 발생하면, 웹브라우저는 그 요소에 등록된 이벤트 핸들러 실행

ex) obj.addEventListener("이벤트",실행할 함수);

 

** 배열 **

1. 여러개의 값을 가지는 자료구조

2. 자료형의 제약 없음

3. trailing(길게 늘어지는) 쉼표

- 객체와 마찬가지로 배열의 마지막 요소에 쉼표 작성 가능

- 모든 행의 구조가 같아져 요소추가, 삭제 용이

 

* 객체(object)와 배열

1. 객체: 키를 사용해 식별할 수 있는 값을 담은 컬렉션

2. 배열: 순서가 있는 컬렉션을 저장할 때 쓰는 자료 구조

 

* 배열 선언

1. let arr = new Array();

2. let arr = new Array("사과","배","기타");

3. let arr = [ ];

4. let fruits = ["사과", "딸기", "포도" , "배"];

5. let arr = ["사과", {올리브 : "올리브 유" }, true, function() {alert("hellow")} ];

- arr[0] // 사과

- arr[1] // 올리브 : "올리브 유"

- arr[4] // fuction() {alert("hellow")}

6. 다차원 배열

let matrix = [

[ 1,2,3 ],

[ 4,5,6 ],

[ 7, 8, 9 ]

];

- matrix[1][1] ; // 5

 

* 배열 요소 구하기

let fruits = ["사과", "오랜지", "자두"]

let fruits[0] // "사과"

 

*배열 길이 구하기

1. length

let fruits = ["사과", "오랜지", "배]

fruits.length; // 3

 

* 배열 요소 수정

fruits[2] = '배'; // 배열이 ["사과", "오랜지", "배"]로 변경

 

* 배열 요소 추가

1. 다음요소에 배열 추가

fruits[3] = '레몬'; // 배열이  ["사과", "오렌지", "배","레몬"]으로 변경

fruits[fruits.length] // = '레몬';

2. 임의 위치에 배열 추가

fruits[6] = '수박'; // ["사과", "오렌지", "배", "레몬", "", "", "수박"] => 빈 배열 추가

 

** 메소드 **

1. push(): 맨 끝에 요소 추가(fast)

2. pop(): 맨 끝에 요소 추출(fast)

3. shift(): 제일 앞 요소를 꺼내 제거한 후 남아있는 요소들을 앞으로 이동(slow)

- 두 번째 요소가 첫 번째 요소로 변경

4. unshift(): 맨 앞에 요소 추가(slow)

 

* 자료구조 *

1. 큐(Queue)

-  순차적 데이터

-  FIFO(선입선출) : 먼저 입력된 데이터가 먼저 삭제

shift <- [1,2,3] <- push

2. 스택 (Stack)

-  데이터의 입출력 위치 고정

-  LIFO(후입선출) : 나중에 입력된 데이터가 먼저 삭제

[ 1, 2, 3 ] push <-> pop

 

** JavaScript 오류 **

1. JavaScript는 오류가 발생하면 일반적으로 중지되고 오류 메시지 생성

2. 기술용어 : JavaScript will throw an exception (throw an error)

3. name & message 속성을 가진 Error 객체 생성

- 이름 : 오류 이름을 설정하거나 반환

- 메시지 : 오류 메시지(문자열)를 설정하거나 반환

 

* 오류 유형

1. ReferenceError (잘못된 참조) : 선언되지 않은 변수를 사용(참조)하는 경우 발생

# EX)

let x =5;

try{
x = y + 1; // y cannot be used (referenced)
} catch(err) {
document.getElementById("demo").innerHTML = err.name;
}

2. SyntaxError(구문 오류) : 구문 오류가 있는 코드를 평가하려고 할 때 발생

# ex
try {
	eval("alert('hello)"; // Missing ' will produce an error
    }catch(err){
    document.getElementById("demo").innerHTML = err.name;
    }

3. TypeError(유형 오류) : 예상 유형 범위를 벗어난 값을 사용하면 발생

# EX)
let num = 1;
try {
num.toUpperCase(); // you cannot convert a number to upper case
} catch(err) {
document.getElementById("demo").innerHTML = err.name;
}

** 오류 처리 **

1. try : 실행할 코드 블록 정의

2. catch : 오류를 처리할 코드 블록 정의, try문과 사용

# 구조
try {
Block of code to try
} catch(err) {
Block of code to handle errors
}

3. throw : 사용자 정의 오류 정의

# 구조
try{
Block of code to try
if(condition)throw "Error Message";
} catch(err){
Block of code to handle errors
}

4. finally : 결과에 관계없이 실행할 코드 블록 정의

# 구조
try{
Block of code to try
} catch(err){
Block of code to handle errors
} finally {
Block of code to be executed regardless of the try / catch result
}
728x90

'CODING PRACTICE > JavaScript & ES6' 카테고리의 다른 글

Pagination 공식  (0) 2023.08.10
2023/04/11__JavaScript__05  (0) 2023.04.13
2023/04/10__JavaScript__04  (0) 2023.04.12
2023/04/07__JavaScript__03  (0) 2023.04.11
2023/04/03__JavaScript__01  (0) 2023.04.06
반응형

* 자바스크립트

  1. 웹 브라우저에서 읽고 실행되는 언어
  2. 보안성이 없음
  3. html 내에 작성
  4. 대소문자의 구분엄격

* 적용 방법

1. 내부 스크립트

- html 문서 내에 스크립트 정의 후 직접 작성

- 필요한 위치에

<script type = "text/javascript">
<!-- 스트립트 효과 -->
</script>

2. 외부 스크립트

- 스크립트 효과를 다른 문서에 작성하고 "이름.js"로 저장

- 효과를 적용할 문서에

<script type="text/javascript" src="이름.js">
다른 문장 작성 금지
</script>

*** 자료형(Data Type) ***

연산에 사용되는 값의 종류

 

* 상수 : 값이 정해져 있는 형식

1. 정수

 - 음수(-), 소수(.)를 제외한 야의 실수

 - 8진수, 16진수 포함

2. 실수

 - 실제 사용 가능한 모든 수

3. 문자형 상수(String)

 - 일반적인 테스트

 - ""사용

4. 불리언(boolean)

 - true(1) / false(0)의 형식

5. null

 - 값이 없음

 

* 변수(variable)

1. 변할 수 있는 값

2. 값을 저장하는 장소나 이름

3. 변수 선언문

-var : 변수 재선언 & 변수 재할당 가능, 생략 가능

  ex)var abc

-let : 변수에 재할당,재선언 불가능, 블록 스코프

-const : 변수 재선언, 변수 재할당 불가능 , 블록 스코프, 초기값 반드시 선언

4. 선언과 동시에 값 입력 가능

var abc=1
var abc
abc = 1

var a,b,c,
a=1
b=2
c=3

var a,b,c = 1
var a=b=c=1

** 이름 규칙 **

1. 알파벳, 숫자 사용 가능

2. 한글, 특수문자, 공백 사용 불가

(단 특수문자 중 "_"는 사용가능)

3. 첫번째 글자는 "_"또는 알파벳만 가능

4. 대소문자 반드시 구분

5. 예약어 사용 불가

 

** 연산자 **

* 산술 연산자

1. +

2. -

3. *

4. /

5. %: 두개의 수를 나눈 나머지

  10/3=3.333334

  10%3=1

* 연결 연산자

1. +: 연산자의 좌변과 우변의 값이 산술 연산이 불가능한 경우 두 개의 값을 이어주는 연산자

ex) 1+2=3 <---산술 연산이 가능하므로 "산술연산자"

   "a" + 1 = a1 <-- 두 개의 값을 연결하는 "연결연산자"

* 비교 연산자 : 결과 값이 true / false로 출력

1. > 

2. <

3. ==

4. <=

5. >=

6. != : ! = not, 아니다

a == b / a != b

 

*논리 연산자

좌변과 우변의 식을 검토하여 결과 산출

1. &&(and) : 좌변과 우변의 식이 모두 참인 경우에 참 값 반환

2. || (or) : 좌변과 우변의 식 중 하나라도 참이면 참값 반환3

3. ^(Xor) : 좌변과 우변 중 하나만 참인 경우 참값 반환

4. !(not) : 반대 값 반환

 

* 비트식 연산자

논리 연산자와 같은 연산자이지만 연산 기호가 1개이고 값이 1(true), 0(false)로 출력

 

* 대입 연산자

1. "=" 기호가 들어간 연산식

2. 좌변과 우변에 동일식이 존재하는 경우 약식 가능

ex) a = a + b => a += b
    a = a - b => a -= b
    a = a * b => a *= b
    a = a / b => a /= b
    a = a % b => a %= b

* 증감 연산자

1. 변수의 값을 증가 또는 감소시키는 연산자

2. 연산기호 : ++, --

3. 증감 범위: +-1

4. 선행처리(++a),후행처리(a++)

a = 100
a++ : 100 + 1, 101 +1, 102 + 1...
++a : 101,102,103...

a-- : 100-1,99-1,98-1...
--a : 99,98,97...

* 조건 연산자

조건의 결과에 따라 다른 값 출력

1. (조건)? 조건이 참일 경우 : 조건이 거짓일 경우

 

** 제어문 **

해당 언어를 효율적으로 사용할 수 있도록 하는 문장

1. 조건문

2. 반복문

 

** 반복문 **

1. 일정한 규칙을 가지고 있는 문장을 직접 작성하지 않고 여러 번 실행시키는 문장

2. 조건(배열, 숫자범위)+반복문

3. for , for.. in , for.. of

4. while

5. do while

 

* while

1. 조건 + 반복문

while(조건){

조건이 참인 동안 반복할 문장

}

* for

1. 형식

for(조건){
--for(시작값;최종값;증감식){}
--for(변수 in 객체){}
--for(변수 of 배열객체){}
조건이 참인 동안 반복할 문장
}

2. 시작값 선언시 변수 선언과 동시에 사용 가능

ex)일반적인 사용 예
var a=1
      b=2
for(a=1; a<=10; a++){
document.write("무궁화 꽃이 피었습니다.")
}
ex) for문의 사용 예
	for(var a=1; a<=10; a++){}
    for(a=1; a<=10;a++){} // var 생략
	for(a=1, b=2; a<=10; a++){} // 여러개의 변수 선언
728x90

'CODING PRACTICE > JavaScript & ES6' 카테고리의 다른 글

Pagination 공식  (0) 2023.08.10
2023/04/11__JavaScript__05  (0) 2023.04.13
2023/04/10__JavaScript__04  (0) 2023.04.12
2023/04/07__JavaScript__03  (0) 2023.04.11
2023/04/04~06__Javascript__02  (0) 2023.04.07

+ Recent posts