2022.05.17

생성자 함수 new Function()

생성자 함수를 PascalCase(파스칼케이스)로 써줌
생성자함수임을 쉽게 알아보기 위해 관행적으로 사용되어지고 있음


function User(first, last) {
  this.firstName = first
  this.lastName = last

  // 메서드. 객체 리터럴 안에 함수표현식
  // 객체의 프로퍼티(속성)에 함수를 할당해 객체에게 행동할 수 있는 능력을 부여해줌
  this.getFullName = function () {
     return `${this.firstName} ${this.lastName}`
   }
  // 속성과 메서드를 합해 *맴버*라 부름
}


// 자바스크립트 = 프로토탑입기반의 프로그래밍언어
// firstName, lastName은 user라는 생성자 함수가 만들어질때마다
// 다른 내용이 들어오기때문에 통일해서 메모리를 관리하기 어렵다
// getFullName 로직은 같기 때문에 통일화 해서 메모리는 좀 더 효율적으로 관리해줄 수 있다
// user함수에 숨어져있는 프로토타입속성에 getFullName을 할당해주면
// 몇개의 객체를 만들더라도 getFullName의 함수는 메모리에 딱 한번만 만들어짐
// 그래서 getFullName()메소드는 위에 함수를 참조한다

// 위와같은 기능을 자바스크립트의 클래스라 부른다
// 생성자함수로 인스턴스를 만들어내는 기능을 자바스크립트의 클래스라 부른다

User.prototype.getFullName = function () {
  return `${this.firstName} ${this.lastName}`
}


// sunny라는 변수에 인스턴스(instance)로 정보가 들어가지고 그 인스턴스틑 하나의 객체데이터
// 생성자함수로 실행한 결과를 반환해서 할당된 그 변수를 생성자 함수의 인스턴스라 부름
// 생성자 함수. 객체데이터 생성
// sunny, amy, jessi => 인스턴스
const sunny = new User('Sunny', 'Yu');
const amy = new User('Amy', 'Park');
const jessi = new User('Jessi', 'Kim');

// .과 []는 동일하게 동작
// .getFullName() 메소드 실행
console.log(sunny['getFullName']()) //Sunny Yu
console.log(amy.getFullName()) //Amy Park
console.log(jessi.getFullName()) //Jessi Kim

this

일반(Normal)함수는 _호출 위치_에 따라 this정의
화살표(Arrow)함수는 자신이 선언된 _함수 범위_에서 this정의

const sunny = {
  name: 'Sunny',
  //익명함수 메소드
  normal: function () {
    console.log(this.name)
  },
  // 화살표 함수 메소드
  // 화살표 함수가 선언된 범위 주변에 함수가 보이지 않아서 undefined가 출력
  arrow: () => {
    console.log(this.name)
  }
}
// sunny객체의 nromal, arrow 메소드 실행
sunny.normal()
sunny.arrow()

const jessi = {
  name: 'Jessi',
  //normal이라는 함수데이터가 normal에 할당되고 있다.
  //뒤에 소괄호()가 없기떄문에 호출이 아니다
  normal: sunny.normal,
  arrow: sunny.arrow
}

jessi.normal()
jessi.arrow()
//파스칼케이스로 작성된 것만 봐도 생성자 함수라는걸 눈치채주기
function User(name) {
  this.name = name
}
// User함수에 프로토타입 normal메소드 
User.prototype.normal = function () {
  console.log(this.name)
}
User.prototype.arrow = () => {
  console.log(this.name)
}

//sunny라는 인스턴스 생성. 즉, 변수
const sunny = new User('Sunny')

sunny.normal()
sunny.arrow()

//name과 timeout이라는 속성값, 메소드가 작성되있음
const timer = {
  name: 'Coffee',
  timeout: function () {
    // setTimeout(함수, 시간)
    setTimeout(() => {
      console.log(this.name)
    }, 2000)
  }
}
timer.timeout()

const timer = {
  name: 'Coffee',
  timeout: function () {
    // setTimeout(함수, 시간)
    setTimeout(function () {
      console.log(this.name)
    }, 2000)
  }
}
timer.timeout() //undefined
// 일반 함수는 호출 위치에 따라서 this 정의되기때문에
// setTimeout로직 어딘가에서 실행이되기때문에

ES6 Classes

const sunny = {
  name: 'Sunny',
  //익명함수 메소드 function키워드로 만들어진 일반함수와 개념이 같다
  //소괄호와 함께 중괄호가 있으면 
  normal() {
    console.log(this.name)
  },

  arrow: () => {
    console.log(this.name)
  }
}

sunny.normal()
sunny.arrow()

function User(first, last) {
  this.firstName = first
  this.lastName = last

}
User.prototype.getFullName = function () {
  return `${this.firstName} ${this.lastName}`
}

class User {
  //내부함수
  // constructor: function () {} 와 같음
  constructor(first, last) {
    this.firstName = first
    this.lastName = last
  }
  getFullName() {
    return `${this.firstName} ${this.lastName}`
  }
}


const sunny = new User('Sunny', 'Yu');
const amy = new User('Amy', 'Park');
const jessi = new User('Jessi', 'Kim');


console.log(sunny)
console.log(amy.getFullName()) 
console.log(jessi.getFullName())

클래스 확장(상속)

class Vehicle {
  //constructor: function () {}
  constructor(name, wheel) {
    this.name = name
    this.wheel = wheel
  }
}
const myVehicle = new Vehicle('운송수단', 2)
console.log(myVehicle)

//extends확장(상속)
class Bicycle extends Vehicle {
  constructor(name, wheel) {
    //super는 확장된 Vehicle을 의미
    super(name, wheel)
  }
}
const myBicycle = new Bicycle('삼천리', 2)
const daughterBicylce = new Bicycle('세발', 3)
console.log(myBicycle)
console.log(daughterBicylce)

class Car extends Vehicle {
  constructor(name, wheel, license) {
    super(name, wheel)
    this.license = license
  }
}
const myCar = new Car('벤츠', 4, true)
const daughtersCar = new Car('포르쉐', 4, false)

console.log(myCar)
console.log(daughtersCar)

2022.05.16

비동기처리방식

함수호출 -> 코드평가 -> 함수실행컨텍스트생성 -> 실행컨텍스트 스택(=콜스택)에 push(실행순서관리) -> 함수실행 -> 종료(콜스택에서) pop

  1. 콜스택에 webAPIs인건 전달을 받아 콜백큐에 쌓여있다
  2. 이벤트루프를 통해서 (콜백)큐에 쌓여있는걸 언제 출력할까?
  3. 콜스택이 비워지면

!!!!이벤트루프를 적용해보자 click!!!!!

위 사이트에 아래의 예시를 넣고 실행순서를 확인해보자

setTimeout(function () {
    console.log(3)
},3000)

function a () {
    console.log(1)
    function b() {
        console.log(2)
    }
    b()
}
a()

자바스크립트는 한번에 하나의 테스크만 실행 가능하기때문에 싱글스레드(single thread) 라 부르며, 브라우저에 내장된 자바스크립트 엔진이 작동함
자바스크립트는 단 하나의 콜스택(callstack)을 갖음
대표적으로 webAPIs에저 지원하는 명령 DOM, AJAX, Timeout

비동기와 동기방식의 차이

비동기: 블로킹(작업중단)현상 발생하지 않음
동기: 실생순서를 보장해 주지만, 블로킹 발생

이벤트루프(Event Loop)

자바스크립트에서 동시성(concurrency)지원
브라우저에 내장된 기능
순차적(FIFO:First In First Out)으로 태스크큐에 대기중인 함수를 콜스택에 이동

메모리 힙(Memory Heap)

객체가 저장되어 있는 장소
메모리 공간크기는 런타임때 결정되어서 구조화되어있지 않음
콜스택의 요소인 실행컨텍스트는 힙에 저장된 객체를 참조함

끄적...
node는 로컬을 제어하는 환경
자바스크립트는 브라우저를 제어하는 환경
ESM방식과 CommonJS방식이 다르다

2022.04.28

While문과 For문

loop(반복문)을 사용하면 동일한 코드를 여러번 반복할 수 있음

while문

while(condition) {
  // 코드
  // '반복문 본문(body)'라 불림
  // condition이 truthy면 코드가 실행됨
  // 조건이 falsy가 되면 반복문은 멈춤
}
let i = 0;
while (i < 3) {
  console.log(i) //0 1 2 출력
  i++
}
조건문이 한줄이면 대괄호{} 생략가능
while (i < 3) console.log(i++)

반복문 안에는 비교뿐만 아니라 모든 종료의 표현식, 변수가 올 수 있음

do.. while 반복문

do {
  반복문 본문
} while (condition);
본문이 먼저!(truthy여부와 상관없이 최소한 한번이라도 실행하고 싶을때만 사용
let i = 0;
do {
  console.log( i ) //0 1 2 출력
  i++
} while(i < 3)

for 반복문

for(초기화; 종료; 변화)
초기화: 반복문 진입할때 단 한 번 실행
종료: 반복마다 해당 조건확인. false면 멈춤
변화: 각 반복의 body부분이 실행된 이후 실행됨

  • for of배열 데이터를 반복할때 쓴다 (Object 해당 x)
  • for in객체 (key값에는 접근 가능, value값에는 직접접근불가능, 배열에서는 index값
    for in문은 순서 보장되지 않음, legnth연산자 사용불가, value값은 string이라 연산 불가능
for (let i = 0; i < 3; i++) {
  console.log(i) //0 1 2 출력
}
'카운터'변수 `i`를 반복문 안에서 선언= 인라인 변수 선언으로 선언한 변수는 반복문 안에서만 접근가능
인라인 변수 선언 대신, 정의되어있는 변수를 사용할 수 있음
let i = 0;
for (i = 0; i < 3; i++) {
  console.log(i) // 0 1 2
}
console.log(i) // 3
for문 begin(초기화)부분, (step)변화부분 생략가능 단, 생략시 세미콜론(;) 꼭 넣어줘야함
반복문 빠져나오기

반복문은 대개 falsy가 되면 종료
break를 쓰면 언제든 빠져나올 수 있음(본문 가운데 똔느 본문 여려곳에서 조건을 확인해야 하는 경우, '무한반복문+break'조합사용)

다음 반복문 넘어가기

countinue는 전체 반복문을 멈추지는 않지만 현재 실행중인 iteration을 멈추고 다음 iteration을 강제 실행(조건을 통과할 시)

!break, continue는 삼항 연산자에는 사용 할 수 없다
!break, continue는 반목문 안에서만 사용 가능, 레이블은 반드시 break, continue 위에 있어야 함
중첩 반목문을 한번에 빠져나와야 할때

레이블(lable): for(...) {...}
레이블로 시작해 break(lableName)을 붙여주면 헤이블에 해당하는 반복문을 빠져나올 수 있음

let num;

do {
  num = prompt('100을 초과하는 숫자를 입력하세요', 0)
} while (num <= 100 && num)

(num <= 100 && num) num가 <= 100인지 확인. num가 null이나 빈 문자열이면 && num이 거짓이 되므로 while반복문 종료

2022.04.26

구조 분해 할당(Destrucuring assignment). 비구조화 할당

객체데이터에서의 구조 분해 할당

const user = {
  name: 'sunny',
  age: 31
}
// user라는 객체데이터에서 내용을 구조 분해해서 내가 원하는 속성만 꺼내서 사용할 수 있음
// 구조분해한 내용을 변수로 만들어서 활용할 수 있음

const {name, age, email} = user
console.log(`이름:${name}`) //이름:sunny
console.log(`나이:${age}`) //나이:31
console.log(`이메일:${email}`) //이메일:undefined 

//email부분에 기본값을 주고 싶다면? email변수부분에 default값 지정가능
const {name, age, email = 'hungry'} = user
console.log(`이름:${name}`) //이름:sunny
console.log(`나이:${age}`) //나이:31
console.log(`이메일:${email}`) //이메일:hungry

//변수 name이 마음에 안들면 콜론기호를 써서 변경 가능 
const {name: hi, age, email = 'hungry' } = user
// name은 꺼내오는 용도, 꺼내온 내용을 hi라는 변수로 만듦

배열데이터에서의 구조 분해 할당

// 배열데이터에 전개연산자를 붙이면 배열데이터의 대괄호가 난라감
// 배열데이터가 가지고있는 괄호를 지워준다고 생각하면 편함
const users = ['Sunny', 'Jessie', 'Rosie']
// users가 배열이라는걸 알고 있기때문에 대괄호를 사용해 주면 됨
// 구조분해 데이터타입에 맞게 기호를 사용해주기
// 배열데이터는 순서대로 추출!
const [a, b, c, d] = users
console.log(a, b, c, d) //Sunny Jessie Rosie undefined

// Rosie만 추출하고 싶을 경우
// 배열데이터는 순서대로 추출!되기때문에 맞춰줘야함
const [, , c] = users
console.log(c) //Rosie
 const a = {
   x: 1,
   y: 2
 }

 const b = {
   y: 3,
   z: 4
 }
 // 하나의 객체데이터 안에서 키는 고유함
 const c = Object.assign({}, a, b) 
 console.log(c) //{x: 1, y: 3, z: 4}

 const d = {
   a,
   b
 }
 console.log(d)
 {
   "a": {
       "x": 1,
       "y": 2
   },
   "b": {
       "y": 3,
       "z": 4
   }
 }

 배열데이터 안에 있는 애들을 날려준다
 const d = {
   ...a,
   ...b
 }
 console.log(d) //{x: 1, y: 3, z: 4}
 const userA = {
   name: 'Sunny',
   age: 92,
   isVaild: true
 }
 // 배열안에 배열이 있네 ? 2차원 배열
 배열안에 배열아이템이 들어있음
 const res = Object.entries(userA)
 console.log(res)
  [
    [
        "name",
        "Sunny"
    ],
    [
        "age",
        92
    ],
    [
        "isVaild",
        true
    ]
  ]
 for (const item of res) {
   console.log(item)
 }
  ['name', 'Sunny']
  ['age', 92]
  ['isVaild', true]
//객체데이터의 key value 형태가 배열형태로 나옴
console.log(item[0]) //key
console.log(item[1]) //value

// Object.entries는 2차원배열로 만들어줌
// 함수는 항상 실행된 데터 뭐 남으냐를 잘 봐함 그렇기 때문에 아래 for of문을 씀
// 즉,
for (const item of Object.entries(userA)) {
  console.log(item[0]) // name age isVaild
  console.log(item[1]) // Sunny 92 true
}

전개 연산자(Spread) 나머지매개변수

...가 전개 연산자 기호
배열데이터가 문자데이터 형태로 출력됨
배열데이터에 전개연산자를 붙이면 배열데이터의 대괄호가 날라감(배열데이터가 가지고있는 관호를 지워준다고 생각하면 편함)

const users = ['Sunny', 'Jessie', 'Rosie']

console.log(users) //['Sunny', 'Jessie', 'Rosie']
console.log(...users) //Sunny Jessie Rosie
console.log('Sunny', 'Jessie', 'Rosie') //Sunny Jessie Rosie

function toObject(a, b, c) {
  return {
    a: a,
    b: b, 
    c: c
  }
}
console.log(toObject(...users)) //{a: 'Sunny', b: 'Jessie', c: 'Rosie'}
console.log(toObject(users[0], users[1], users[2])) //{a: 'Sunny', b: 'Jessie', c: 'Rosie'}

const users = ['Sunny', 'Jessie', 'Rosie', 'Amy', 'Sarah']

//위에 toObject를 화살표함수로 축약함

const toObject = (a, b, ...c) => ({a, b, c})
//매개변수 부분에 전개연산자를 넣어주면 나머지 아이템들은 전부 c로 들어갈 수 있음 (=rest parameter 나머지 매개변수)
//매개변수에서 나머지값을 배열의형태로 받을 수 있음
console.log(toObject(...users)) 
//{a: 'Sunny', b: 'Jessie', c: Array(3)}, 
//                          c: (3) ['Rosie', 'Amy', 'Sarah']
const a = {
  x: 1,
  y: 2
}

const b = {
  y: 3,
  z: 4
}
// 하나의 객체데이터 안에서 키는 고유함
const c = Object.assign({}, a, b) =  
console.log(c) //{x: 1, y: 3, z: 4}

const d = {
  a,
  b
}
console.log(d)
{
  "a": {
      "x": 1,
      "y": 2
  },
  "b": {
      "y": 3,
      "z": 4
  }
}

배열데이터 안에 있는 애들을 날려준다
const d = {
  ...a,
  ...b
}
console.log(d) //{x: 1, y: 3, z: 4}

전개연산자와 (객체)구조분해할당

const user = {
  name: 'Sunny',
  age: 92,
  isValid: true
}
// const e = user.name
// const a = user.age
// const i = user.isValid

const { name: e, ...rest } = user
console.log(e, rest) //Sunny {age: 92, isValid: true}

2022.04.26

자바스크립트 객체(Object)

객체 속성은 열거자enumerable or 비열거자nonenumerable로 정의할 수 있으며
탐색, 검색, 반복할 수 있는 빌트인(built-in)수단(메서드또는문)들을 제공
Object 메서드중 prototype이 붙어있지 않은건 정적(static)메서드라고함
즉 객체리터럴방식을 직접적으로 사용 불가능 ( {}.assign() )

Object.assign()

열거할 수 있는 하나 이상의 출처 객체로부터 대상 객체로 속성을 복사 할 때 사용

const target = { a: 1, b: 2, c: 3}
const source = { a: 1, b: 4, c: 6}

// target이 대상객체, source가 출처객체
const res = Object.assign(target, source)

// source 값을 target에 복사
console.log(target) //{a: 1, b: 4, c: 6}
그 값이 res에 입력됨
console.log(res) //{a: 1, b: 4, c: 6}
console.log(target === res) //true(배열, 객체, 함수는 참조형데이터 가변성)


//새로운 객체데이터를 만듦(=내용이 비어져있는 개체데이터를 생성)
//빈 객체리터럴을 넣어주면 대상객체가 손상되지 않음
//const res = {} 이거랑 아래{}부분에 res쓴거랑 같당
const other = Object.assign({}, target, source)

console.log(target) //{a: 1, b: 2, c: 3}
console.log(other) //{a: 1, b: 4, c: 6}
console.log(other === target) //false

Object.keys()

객체데이터의 key값을 새로운 배열로 만들어 줌

const target = { 
  a: 1, 
  b: 2, 
  c: 3
}

const keys = Object.keys(target)
console.log(keys) //['a', 'b', 'c']

// 객체데이터도 인덱싱방법을 제공
console.log(target['a']) //1

// map이라는 Array메서드
const values = keys.map( function(key) {
  return target[key]
} )
console.log(values) // [1, 2, 3]
const userA = {
  name: 'Sunny',
  age: 92,
  isVaild: true
}

const res = Object.keys(userA)
//객체 key들을 배열로 내놓음
console.log(res) //['name', 'age', 'isVaild']

// 메소드체이닝
Object.keys(userA).forEach(item => {
  console.log(userA[item])})
// 흔적을 남기기때문에 앞에 res를 지워줘도 될거같아요 res가 그 값을 받기때문에
res.forEach( item => {
  // userA.name //점표기법
  // userA.['name'] //대괄호 표기법
  console.log(userA[item])
})

Object.values()

객체의 value값 반환

const userA = {
  name: 'Sunny',
  age: 92,
  isVaild: true
}

const res = Object.values(userA)
console.log(res) //['Sunny', 92, true]

2022.04.27

Javascript Date

const date = new Date()
console.log(date.getFullYear())
console.log(date.getMonth()) // +1
console.log(date.getDate()) 
console.log(date.getHours()) 
console.log(date.getMinutes()) 
console.log(date.getSeconds())

// 날짜출력방법
const res = `${year}.${month}.${day}`; //년.원.일 변수 res로
const today = document.querySelector('.date'); //data클래스
today.textContent = res;

2022.04.25

Array(배열)

배열데이터 내부의 Elemente(요소)들을 item이라 지칭
인수로 사용되는 하나의 함수를 콜백함수라함

.length

Array.prortotype.length
prototype이 써있으면 배열데이터를 리터럴방식으로 쓸 수 있다 ( [].length )

const fruits = ['Apple', 'Mango', 'Banana']
console.log(fruits) // (3) ['Apple', 'Mango', 'Banana']
console.log(fruits.length) //3
console.log([].length) //0

.concat()

두개의 배열데이터를 병합해서 새로운 배열데이터를 반환
원본 데이터에 전혀 영향이없음

 const fruits = ['Apple', 'Mango', 'Banana']
 const users = ['Sunny', 'Jessi', 'Rosie']

 console.log(fruits.concat(user)) // ['Apple', 'Mango', 'Banana', 'Sunny', 'Jessi', 'Rosi']
 console.log(fruits)
 console.log(users)

.forEach()

배열데이터의 아이템의 개수만큼 특정한 콜백함수를 반복적으로실행
갯수만큼 반복하기때문에 반복을 멈추고 싶어도 배열이 끝나면 끝날 수 있다

 const users = ['Sunny', 'Jessi', 'Rosie']
 users.forEach(function(element, index, array) {
   console.log(element, index, array)   
 })

 Sunny 0 (3) ['Sunny', 'Jessi', 'Rosie']
 Jessi 1 (3) ['Sunny', 'Jessi', 'Rosie']
 Rosie 2 (3) ['Sunny', 'Jessi', 'Rosie']

 // 다른 배열반목문들

const arr = [1, 2, 3, 4]
for (let i = 0; i < arr.length; i += 1) {
  console.log(arr[i])
}
for (const item of arr) {
  console.log(item)
}

.map()

return키워드를 통해 반환값을 새로운 배열데이터로 만들어서 사용할 수 있다
반환된 값은 true, false로 반환

 forEach()는 따로 반환되는 값은 없다
 배열데이터 참조(:값이 연결되있다)
 const users = ['Sunny', 'Jessi', 'Rosie']
 const a = users.forEach( function (user, index) {
   return {
     name: user,
     number: index
   }
 })
 console.log(a) //undefined

 // return키워드로 값을 밖으로 반환함
 // 객체를 새로운 배열로 만들어줌
 const users = ['Sunny', 'Jessi', 'Rosie']
 const a = users.map( function (user, index) {
   return {
     name: user,
     number: index
   }
 })
 console.log(a)
 (3) [{…}, {…}, {…}]
 0: {name: 'Sunny', number: 0}
 1: {name: 'Jessi', number: 1}
 2: {name: 'Rosie', number: 2}
 length: 3

.filter()

배열데이터 각각의 아이템들을 true인 값만 반환
주어진함수(콜백) 테스트를 통과한 애들만 가지고 새로 생성해서 반환
원본배열에서보다 갯수가 줄어들어듬

 const num = [1, 2, 3, 4]
 const a = num.filter(num => num < 3)
 console.log(a) //(2) [1, 2]

map(),filter()는 새로운 배열을 반환하는 매서드

.find() .findIndex()

 const num = [1, 2, 3, 4]
 const users = ['Sunny', 'Jessi', 'Rosie']

find() 불린데이터로 찾아진 배열의 첫번째 요소(item)반환. 없으면 undefinded

 const a = users.find(user => /^R/.test(user))

 console.log(a) //Rosie

findIndex()는 해당하는 부분의 index번호를 반환해줌
 const b = users.findIndex(user => /^R/.test(user))

 console.log(b) //2

.includes()

인수안에 데이터가 포함되어있는지를 불린데이터형태로 반환

 const num = [1, 2, 3, 4]
 const users = ['Sunny', 'Jessi', 'Rosie']

 const a = num.includes(3)
 console.log(a) //true

 const b = users.includes('Jenny')
 console.log(b) //false

.join()

배열의 모든 요소를 특정한 기호로 연결해서 하나의 문자(string) 로 만들어서 반환함

const arr = [1, 2, 3, 4]
 console.log(
   arr.join(',') //1,2,3,4
 )

.pop() .shift()

const arr = [1, 2, 3, 4]

.pop()
기존 배열에서 마지막 요소를 제거하고 그 요소를 반환
원본이 수정됨

console.log(
  arr.pop() //4
)
console.log(arr) //[1, 2, 3]

.shift()
기존 배열에서 맨앞 요소를 제거하고 그 요소를 반환

console.log(
  arr.shift() //1
)
console.log(arr) //[2, 3, 4]

.push() .unshift()

맨 끝에 하나이상의 요소를 추가하고, 배열의 새로운 길이를 반환
원본 수정됨 주의!

 const num = [1, 2, 3, 4]
 const users = ['Sunny', 'Jessi', 'Rosie']

.push()

 배열데이터의 가장 뒷쪽 부분에 데이터 삽입
 num.push(5)
 console.log(num) //[1, 2, 3, 4, 5]

.unshift()

 배열데이터의 가장 앞쪽 부분에 데이터 사입
 num.unshift(0)
 console.log(num) // [0, 1, 2, 3, 4, 5]

.reverse()

배열아이템 순서를 뒤집는다
원본 수정됨 주의!

 const num = [1, 2, 3, 4]
 num.reverse()
 console.log(num) //(4) [4, 3, 2, 1]

.splice()

원본 수정됨 주의!
인덱스 값을 넣음
.splice(인덱스, 삭제개수, 추가데이터)

const arr = [1, 2, 3, 4, 5]
console.log(
  arr.splice(2, 2, 7) // [3, 4] 제거한 요소를 담은 배열을 반환
)

console.log(arr) // [1, 2, 7, 5]
// 아무것도 지우지 않고 2번째 index에 끼워넣고 싶을경우
// arr.splice(2, 0, 7) 으로 해주면 됨

.every()

모든 값이 통과해야 true

// 4번 반복될거고, return으로 반환된 값이 전부 Truthy 여야지만이 true가 나올거임
const arr = [1, 2, 3, 4]
console.log(
   arr.every(item => item < 5)  //콜백함수 하나를 받습니다
 ) //true

console.log(
  arr.every(item => item < 4)  
) //false 모두통과해야 true

.reduce()

첫번째 인수는 콜백함수, 두번째 인수가 있음(내가 원하는 초기값 지정. 현재 처리할 요소)
acc: 누적되는 그 값 accumulator
누적이 최초로 시작될 값이 cur이에요!!
cur: 초기값 currentValue

const arr = [1, 2, 3, 4]

const sum = arr.reduce((acc, cur, index) => {
  console.log(index) // 0 1 2 3
  return acc + cur
}, 0)

1. acc값에 초기값 cur`0`이들어가고 cur에 arr 인덱스[0]인 1이 들어감 0 + 1 = 1
2. return키워드를 통해 acc에 1, cur에 arr 인덱스[1]인 2이 들어감 1 + 2 = 3
3. return키워드를 통해 acc에 3, cur에 arr 인덱스[2]인 3이 들어감 3 + 3 = 6
4. return키워드를 통해 acc에 6, cur에 arr 인덱스[3]인 4이 들어감 6 + 4 = 10
5. 이제 반복할 item이 없으니 최종적으로 변수`sum`에 값이 들어가서 console.log(sum) = 10

// 화살표 함수
const sum = arr.reduce((acc, cur) => acc + cur, 0)
console.log(sum) // 10
//reduce()는 콜백이 하나의 누적값을 다음 콜백값으로 넘겨줄 수 있음

forEach() 외부 변수 필요

const arr = [1, 2, 3, 4]
 let sum = 0
 arr.forEach(item => {
   sum += item
 })
 console.log(sum) // 10

.slice()

string에도 ,slice()메소드 존재

const arr = [1, 2, 3, 4, 5]
console.log(arr.slice(0, 3)) //[1, 2, 3]

.some()

배열 안의 어떤 요소라도 주어진 판별 함수를 통과하는지 테스트
전체아이템중에 하나라도 통과하면되요

console.log(
  arr.some( item => {
    return item === 1
  })
) //true

// 화살표 함수
console.log(
  arr.some( item => item === 1)
) //true

2022.04.25

Math

Math는 수학적인 상수와 함수를 위한 속성과 메서드를 가진 내장(자바스크립트에 이미 들어가있는)객체

Math.abs()

//absolute. 주어진 값의 절대값을 반환
console.log('abs:', Math.abs(-7)) //abs:7

Math.min()

//가장 작은값을 출력해줌
console.log('min:', Math.min(5, 12)) //min:5

Math.max()

//가장 큰값을 출력해줌
console.log('max:', Math.max(5, 12)) //max:12

Math.ceil()

//올림처리한 값을 출력
console.log('ceil:', Math.ceil(3.14)) //ceil:4

Math.floor()

//내림처리한 값을 출력
console.log('floor:', Math.floor(3.14)) //floor:3

Math.round()

//반올림한 값을 출력
console.log('round:', Math.round(3.14)) //round:3

Math.random()

//랜덤한 숫자를 출력
console.log('random:', Math.random())
const pi = 3.14159265
console.log(pi)

const str = pi.toFixed(2) //toFixed는 인수로 소수점 몇번째까지. 문자값으로 변환해줌
console.log(str) //3.14
console.log(typeof(str)) //string

//parseInt, parseFloat는 전역(전체의영역)함수
//setTimeout, setInterval, clearTimeout, clearInterval
const integer = parseInt(str) //3 parse(분석하다)int(정수)
const float = parseFloat(str) //3.14 부동소수점 실수로 파싱후 반환
console.log(integer)
console.log(float)
console.log(typeof integer, typeof float)

+ Recent posts