Computed

<div id="hello">
<p> 역순 : "{{reverseHello}}"</p?

var vm = new Vue({
    el : '#hello'
    data: {
        hello: 'HEOLL'    
    },
    coumputed: {
        reverseHello() {
            return this.hello.split('').reverse().join('')  // LLOEH
        }
    }
})

hello 가 변경되지 않는 한 reverseHello를 여러번 요청해도 계산이 다시 되지 않고 계산 되어 있던 결과를 즉시 반환한다

cf) function

computed는 해당 속성이 변경될때만 함수가 실행된다.

언제 computed 사용?

  • 캐싱을 원하는 경우 사용
  • computed의 set, get속성
computed: {
    fullName: {
        get:function() {
            return this.firstName+''+this.secondName
        },
        set:function() {
            let name=newValue.splite('')
            this.firstName = names[0]
            this.lastName = name[names.length-1]
        }
    }
}

watch

  • 옵션

    deep: true - Objects 내부의 중첩된 값 변경 감지

    immediate: true - 표현식의 현재 값으로 즉시 콜백 호출

    • 첫번째 콜백할때 호출함

    • 만약, 콜백대신에 unwatch 함수를 먼저 호출하고 싶으면

      watch: {
        value: {
            handle(newVal) {
                this.doSomething()
            }
            immediate: true
        }
      }

       

'Vue.js > vue2' 카테고리의 다른 글

[vue2] 뷰 라이프 사이클 다이어그램  (0) 2020.09.30
[vue2] 인스턴스  (0) 2020.09.30
[vue2] 용어 및 기본 개념  (0) 2020.09.30
[vue2] vue 규칙  (0) 2020.09.30

beforeCreate

  • 인스턴스가 생성되고 나서 가장 처음으로 실행되는 라이프 사이클 단계
  • data, methods 속성은 아직 정의 되지 않고 돔과 같은 화면 요소에도 접근 불가

created

  • beforeCreate 라이프 사이클 단계 다음에 실행되는 단계
  • data 속성과 methods 속성이 정의되어있어 this. data 또는 this. fetchData()와 같은 로직을 이용해 data 속성과 methods 속성에 정의된 값에 접근해 로직을 실행할 수 있음
  • 아직 인스턴스가 화면요소에 부착되지 전이므로 template 속성에 정의된 돔 요소로 접근 불가
  • data 속성과 methods 속성에 접근하기 가장 좋아 서버에 데이터를 요청하여 받아오는 로직을 수행하기 좋음

beforeMount

  • created 단계 이후 template 속성에 지정한 마크업 속성을 render()함수로 변환 후 el 속성에 지정한 돔에 인스턴스를 부착하기 전에 호출하는 단계

    cf) render() -자바스크립트로 화면의 돔을 그리는 함수

mounted

  • el 속성에서 지정한 화면 요소에 인스턴스가 부착되고 나면 호출되는 단계로, template 속성에 정의한 돔에 접근할 수 있어 화면 요소를 제어하는 로직을 수행하기 좋은 단계

  • 다만 ! 돔에 인스턴스가 부착되자마자 바로 호출되기 때문에 하위 컴포넌트나 외부 라이브러리에 의해 추가된 화면 요소들이 최종 html 코드로 변환되는 시점과 다를 수도 있음

    cf ) 반환되는 시점이 다른경우 $nextTick() API 를 활용해 HTML 코드로 최종 파싱 될 때까지 기다린 후 돔 제어 로직을 추가

beforeUpdate

  • el 속성에서 지정한 화면 요소에 인스턴스가 부착되고 나면 인스턴스에 정의한 속성들이 화면에 치환됨
  • 치환된 값은 뷰의 반응성을 제공하기 위해 $watch 속성으로 감시
  • 관찰하고 있는 데이터가 변경되면 가상 돔으로 화면을 다시 그리기 전에 호출되는 단계
  • 변경 예정인 새 데이터에 접근할 수 있어 변경 예정 데이터의 값과 관련된 로직을 미리 넣을 수 있음

updated

  • 데이터가 변경되고 나서 가상 돔으로 다시 화면을 그리고 나면 실행되는 단계
  • 데이터 변경으로 인한 화면 요소 변경까지 완료된 시점으로, 데이터 변경 후 화면 요소제어와 관련된 로직을 추가하기 좋음
  • 이 단계에서 데이터 값을 변경하면 무한 루프에 빠질수 있어 값 변경시 computed, watch 와 같은 속성을 사용해야함
  • 데이터 값을 갱신하는 로직 ⇒ beforeUpdate
  • 변경 데이터의 화면 요소와 관련된 로직 ⇒ updated

beforeDestory

  • 뷰 인스턴스가 파괴되기 직전에 호출되는 단계
  • 아직 인스턴스에 접근이 가능해 뷰 인스턴스의 데이터를 삭제하기 좋음

destoryed

  • 뷰 인스턴스가 파괴되고 나서 호출하는 단계

watch, create에는 화살표 함수를 사용하는 것을 지양
왜? 화살표 함수들은 부모 컨텍스트에 바인딩 되기에 this컨텍스트가 호출하는 vue인스턴스에 사용할 경우 'Uncatch TypeError: ' 가 날 수도 있음

부모 자식 간의 컴포넌트 마운트 순서

이벤트 버스 사용 시 $on 을 못하는 이유

수동 mounting 추천 하지 않음

  • 뷰 컴포넌트 대신에 수동으로 자식 컴포넌트를 마운트 하는 경우 발생
  • dialog 훅을 beforeDestory 대신 destoryed 훅에 놓아 수동으로 꺼줘야함

'Vue.js > vue2' 카테고리의 다른 글

[vue2] computed 와 watch  (0) 2020.09.30
[vue2] 인스턴스  (0) 2020.09.30
[vue2] 용어 및 기본 개념  (0) 2020.09.30
[vue2] vue 규칙  (0) 2020.09.30

인스턴스가 화면에 적용되는 과정

  • 뷰 라이브러리 파일 로딩
  • 인스턴스 객체 생성 (옵션 속성 포함)
  • 특정 화면 요소에 인스턴스를 붙임
  • 인스턴스 내용이 화면 요소로 변환
  • 변화된 화면 요소를 사용자가 최종 확인
new Vue({
    el:'#app',
    data:{
        message: 'Hello Vue.js!'
    }
});
<div id ="app">
    {{message}}
</div>
  • el 속성에 인스턴스가 부착되고 나면 인스턴스에 정의한 옵션 객체의 data이 el 속성에 지정한 화면 요소와 그 이하 레벨의 화면 요소에 적용되어 값이 치환
  • data 속성의 message 값 Hello Vue.j 가 {{message}} 와 치환

속성

computed

  • 산출 속성으로 data 와 비슷하게 사용되는 함수로 인해 산출 되는 데이터

template

  • 화면에 표시할 HTML, CSS 등의 마크업 요소를 정의하는 속성, 뷰의 데이터 및 기타 속성들도 함께 화면에 그릴 수 있음

methods

  • 화면 로직 제어와 관계된 메서드를 정의하는 속성, 마우스 클릭 이벤트 처리와 같이 화면의 전반적인 이벤트와 화면 동작과 관련된 로직을 추가 할 수 있음

created

  • 뷰 인스턴스가 생성되자마자 실행할 로직을 정의하는 속성
  • DOM이 아직 구축되지 않은 상태로 인스턴스 자신을 나타내는 this에 접근할 수 있지만 $el 과 getElementById() 등을 이용해 DOM을 통해서는 접근 불가

속성에 데이터 바인딩 하기

  • 속성에 전개 불가능
<input type="text" value="{{message}}">  
<!--ERROR--!>
  • 속성에 데이터 바인딩 하는법
<input type="text" v-bind:value="message">
<!--생략 하는 방법 --!>
<input type="text" :value="message">

화면에 적용되는 과정

  1. 뷰 라이브러리 파일 로딩
  2. 인스턴스 객체 생성
  3. 특정 화면 요소에 인스턴스를 붙임
  4. 인스턴스 내용이 화면 요소로 변환
  5. 변환된 화면 요소를 사용자가 최종 확인

'Vue.js > vue2' 카테고리의 다른 글

[vue2] computed 와 watch  (0) 2020.09.30
[vue2] 뷰 라이프 사이클 다이어그램  (0) 2020.09.30
[vue2] 용어 및 기본 개념  (0) 2020.09.30
[vue2] vue 규칙  (0) 2020.09.30

왜 node js 필요한가

  • 빌드 자동화
  • 개발 환경 커스터 마이징
  • package.json 항목 의미
    • name
    • version
    • description
    • main:노트 애플리케이션 일 경우 진입점 경로,

Webpack

  • 여러 파일을 하나로 합쳐주는 번들러

  • 번들러

    지정 단위로 하나의 파일로 만들어 요청에 대한 응답을 전달할 수 있는 환경

    옛날과 달리 컴퓨터 성능이 많이 좋아져 모듈 단위로 잘게 나눠서 개발해 유지보수나 가독성이 좋게 함

  • 시작점으로부터 의존 모듈을 모두 찾아 결과물을 만듦

  • 기능

    • 리소스 묶기
    • 바벨을 이용해 es5 코드로 바꿈
    • 변화를 감지해 다시 실행

loader

  • 웹팩은 모든 파일을 모듈로 봄 (자바 스크립트로 만든 모듈, 스타일 시트, 이미지, 폰트 등 전무 모듈로 보기에 import 구문을 이용하면 자바 스크립트 코드 안으로 가져올 수 있음)
    • 어떻게 ? 로더 덕분에

Vue 는 MVVM 패턴

  • Backend 로직과 Client의 마크업, 데이터 표현단을 분리하기 위한 구조
  • 화면 앞단 로직과 뒷단 DB 데이터 처리 및 서버 로직 분리

'Vue.js > vue2' 카테고리의 다른 글

[vue2] computed 와 watch  (0) 2020.09.30
[vue2] 뷰 라이프 사이클 다이어그램  (0) 2020.09.30
[vue2] 인스턴스  (0) 2020.09.30
[vue2] vue 규칙  (0) 2020.09.30
  • 파일명 - 파스칼 케이스 이용
import MyComponent from '@/MyComponent.vue'
export default{
    name: 'MyComponet'
}

// 컴포넌트 사용시 <my-component>
  • 컴포넌트 이름 규칙 - 케밥 케이스 이용
<my-component></my-component>
  • prop 이름 규칙 - 카멜 테이스

    • 추천

      props: {
        greetingText: String
      }
      <WelcomeMessage greeting-text="hi/>
    • 비추천

      props: {
        'greeting-text': String
      }
      <WelcomeMessage greetingText="hi/>
  • 속성값

<!-- good -->
<SideBar : style="{width:sidebar+'px'}"></SideBar>
<!-- bad -->
<SideBar : style={width:sidebar+'px'}></SideBar>
  • style : 범위가 지정됨 스타일과 지정되지 않은 스타일은 동일한 컴포넌트에 포함 할 수 있습니다.
<style>
/*전역 스타일*/
</style>

<style scoped>
/*로컬 스타일*/
</style>

v-if / v-show

v-if

  • 조건에 따라 컴포넌트가 실제 제거 / 생성

v-show

  • 단순 css의 display 속성만 변경

플러그인 사용

Vue.use(Myplugin)

new Vue({
    //options
})

배열 변경 감지

변이 메소드(래핑된 메소드)

→ 호출된 원본 배열을 변형

  • push()
  • pop()
  • shift()
  • unshift()
  • sort()
  • splice()
  • reverse()

배열 대체

→ 호출된 원본 배열을 변형하지 않고 항상 새 배열 반환

  • filter()
  • concat()
  • slice()

인덱스로 배열에 있는 항목을 직접 설정하는 경우 / 배열 길이를 수정하는 경우 → 불가

var vue = new Vue({
    data: {
        items: ['a','b']
    }
})
vue.items[0] ='c' // 불가능
vue.items.length = 1 // 불가능

// sol
Vue.set(vue.items, indexOfItem, newValue)
vue.items.splice(indexOfItem, 1, newValue)

이벤트 수식어

  • .stop - 클릭 이벤트 전파 중단
  • . prevent - 제출 이벤트가 페이지를 다시 로드하지 않음
  • .capture - 수식어 체이닝 가능
  • .prevent - 단순히 수식어만 사용할 수 있음
  • .capture - 이벤트 리스너 추가시 캡처 모드 사용 (내부 element 대상으로 하는 이벤트가 해당 element에서 처리되기전에 먼저 처리)
  • .self - event.target이 element 자체인 경우 트리거에서 처리

@click.prevent.self - 모든 클릭 막을 수 있음
@click.self.prevent - 엘리먼트 자체에 대한 클릭만 방지

주의

  • 변수값 맞추기
  • watch에서 object 변경 감지 . ~~이런식으로 해서 하나씩 못함
var person: {
    familly: {
        count: this.count
        live: this.live
    },
    me: {
        age: this.age
        colleage: this.highschool    
    }
}

-> 해당 객체 watch에서 변경감지해서 사용할 경우
watch:{
    person(newVal, oldVal){
        this.person.familly = newVal.family // 불가능
        this.person.me = newVal.me  // 불가능
        this.person = newVal // 가능
        this.person = Object.assgin({}, newVal) // 가능
    }
}

'Vue.js > vue2' 카테고리의 다른 글

[vue2] computed 와 watch  (0) 2020.09.30
[vue2] 뷰 라이프 사이클 다이어그램  (0) 2020.09.30
[vue2] 인스턴스  (0) 2020.09.30
[vue2] 용어 및 기본 개념  (0) 2020.09.30

unref

  • argument 가 ref 인 경우 내부 value return
function useFoo(x: number | Ref<number>) {
  const unwrapped = unref(x) // unwrapped is guaranteed to be number now
}

toRef

  • 반응성 객체에 ref 사용할 때 씀
  • prop로 ref 넘길 때 용이
const state = reactive({
  foo: 1,
  bar: 2
})

const fooRef = toRef(state, 'foo')

fooRef.value++
console.log(state.foo) // 2

state.foo++
console.log(fooRef.value) // 3
export default {
  setup(props) {
    useSomeFeature(toRef(props, 'foo'))
  }
}

toRefs

  • 일반 객체에서 반응성 객체로 바꿈
  • 여기서 결과 객체의 각 속성은 원본 객체의 해당 속성을 가리키는 참조
  • 반응성 객체를 반환 시 용이
const state = reactive({
  foo: 1,
  bar: 2
})

const stateAsRefs = toRefs(state)
/*
Type of stateAsRefs:

{
  foo: Ref<number>,
  bar: Ref<number>
}
*/

// The ref and the original property is "linked"
state.foo++
console.log(stateAsRefs.foo) // 2

stateAsRefs.foo.value++
console.log(state.foo) // 3
function useFeatureX() {
  const state = reactive({
    foo: 1,
    bar: 2
  })

  // logic operating on state

  // convert to refs when returning
  return toRefs(state)
}

export default {
  setup() {
    // can destructure without losing reactivity
    const { foo, bar } = useFeatureX()

    return {
      foo,
      bar
    }
  }
}

isRef

  • ref 객체 값 체크

isProxy

  • reactive 이거나 readonly 일 때 객체 체크

isReacitve

  • reactive에 의해 만들어진 반응형 proxy 객체 체크
  • 만약 프록시가 readonly로 만들어 진경우 true return
  • 다른 프록시가 reactive에 의해 만들어진 다른 프록시가 감쌈

isReadonly

  • readonly로 만들어진 객체가 readonly인지 체크

'Vue.js > vue3' 카테고리의 다른 글

[vue3] composition API  (0) 2020.09.30
[vue3] Reactivity APIs  (0) 2020.07.02
[vue3] setup  (0) 2020.07.02
[vue3] vue 2 > vue3  (0) 2020.07.02
<template>
  <div>
    <p>Spaces Left: {{ spacesLeft }} out of {{ capacity }}</p>
    <h2>Attending</h2>
    <ul>
      <li v-for="(name, index) in attending" :key="index">
        {{ name }}
      </li>
    </ul>
    <button @click="increaseCapacity()">Increase Capacity</button>
  </div>
</template>
<script>
import { ref, computed } from "vue";
export default {
  setup() {
        // 변화 감지할 데이터 ref 로 묶음
    const capacity = ref(4);
    const attending = ref(["Tim", "Bob", "Joe"]);
    const spacesLeft = computed(() => {
            // ref 로 묶은 데이터 접근시 .value 사용해서 접근 해야함
      return capacity.value - attending.value.length;
    });
        // 함수는 function으로 정의
    function increaseCapacity() {
      capacity.value++;
    }
        // 템플릿에서 해당값들을 접근 가능
    return { capacity, attending, spacesLeft, increaseCapacity };
  }
};
</script>
import { reactive, computed, toRefs } from "vue";
export default {
  setup() {
        // 반응성 값들을 object 로 반환
        // ref와 다르게 .value로 접근할 필요 없음
    const event = reactive({
      capacity: 4,
      attending: ["Tim", "Bob", "Joe"],
      spacesLeft: computed(() => { return event.capacity - event.attending.length; })
    });
    function increaseCapacity() {
      event.capacity++;
    }
        // toRefs로 반응성을 가지고 있는 일반 객체를 만듦 
    return { ...toRefs(event), increaseCapacity };
  }
<template>...</template>
<script>
export default {
    setup() {
        const product = useSearch()
        const result = useSorting()
        return {product, result}
    }
}

function useSearch(getResult) {

}
function useSorting({ input, options }) { 
}
</script>

'Vue.js > vue3' 카테고리의 다른 글

[vue3] Reactivity Utilities  (0) 2020.09.30
[vue3] Reactivity APIs  (0) 2020.07.02
[vue3] setup  (0) 2020.07.02
[vue3] vue 2 > vue3  (0) 2020.07.02

reactivity apis

reactive

  • 모든 속성에 영향을 준다
  • object가 아닌 proxy를 반환
const obj = reactive({ count: 0 })

ref

  • ref object 반환하고 반응성을 반환하고 값을 반환함
  • ref object 는 .value로 값을 가져옴
  • 객체가 참조 값으로 할당되면 반응 방법에 의해 객체 반응
const count = ref(0)
console.log(count.value) // 0

count.value++
console.log(count.value) // 1
  • 템플릿에서 사용할때는 .value를 사용할 필요 없음

  • 반응성 객체 접근

    ref는 반응성 객체를 접근 변경하기 위해서는 자동으로 랩이 해제되어 일반 속성 처럼 동작

const count = ref(0)
const state = reactive({
  count
})

console.log(state.count) // 0

// state.count.value =1 -> X
state.count = 1
console.log(count.value) // 1
  • 현재 ref에 연결된 값이 새로운 ref로 변경됨
  • ref는 reative object에 있을때만 랩이 해제된다
const otherCount = ref(2)

state.count = otherCount
console.log(state.count) // 2
console.log(count.value) // 1
  • array나 collection 타입과 같은 것을 접근할 때 랩을 해체하는 행동이 아니다
const arr = reactive([ref(0)])
// need .value here
console.log(arr[0].value)

const map = reactive(new Map([['foo', ref(0)]]))
// need .value here
console.log(map.get('foo').value)

computed

  • getter 함수를 가져오고 불변의 반응성 ref object를 반환
const count = ref(1)
const plusOne = computed(() => count.value + 1)

console.log(plusOne.value) // 2

plusOne.value++ // error
  • 대안으로, get,set 함수로 object 가져올 수 있음
const count = ref(1)
const plusOne = computed({
  get: () => count.value + 1,
  set: val => {
    count.value = val - 1
  }
})

plusOne.value = 1
console.log(count.value) // 0

readonly

  • 일반, 반응성 객체를 가져오고 읽기만 가능한 proxy를 반환
const original = reactive({ count: 0 })

const copy = readonly(original)

watchEffect(() => {
      // 반응성 관련 일
  console.log(copy.count)
})

// 원본 변경시 사본 감지
original.count++

// 실패 하고 그리고 경고를 반환
copy.count++ // warning!

watchEffect

  • 반응성을 트래킹하며 즉시 함수 시작
  • 의존적인게 바뀌게 되면 바로 re-run
const count = ref(0)

watchEffect(() => console.log(count.value))
// -> logs 0

setTimeout(() => {
  count.value++
  // -> logs 1
}, 100)
  • watcher 멈추는 법
    • setup() 함수를 부르는 동안 watcheffect가 호출됨
    • 컴포넌트 생명주기에 watcher 이 연결 되어 있고 자동적으로 컴포넌트가 unmounted될때 멈춤
const stop = watchEffect(() => {
  /* ... */
})

// later
stop()
  • 무효화의 단점
    • 가끔 watched 함수는 비동기의 단점임
watchEffect(onInvalidate => {
  const token = performAsyncOperation(id.value)
  onInvalidate(() => {
    // id has changed or watcher is stopped.
    // invalidate previously pending async operation
    token.cancel()
  })
})
  • DOM에서 watch를 사용하고 싶으면 mounted 훅에서 사용
onMounted(() => {
  watchEffect(() => {
    // access the DOM or template refs
  })
})
  • watcher 동기 이거나 컴포넌트가 업데이트 된 후 효과가 있음
// fire synchronously
watchEffect(
  () => {
    /* ... */
  },
  {
    flush: 'sync'
  }
)

// fire before component updates
watchEffect(
  () => {
    /* ... */
  },
  {
    flush: 'pre'
  }
)
  • watcher debugging
    • onTrack, onTrigger 옵션이 디버그 watcher 행동을 해줌
    • onTrack - 반응성 property가 호출되거나 ref가 의존되어있을 때
    • onTrigger - watcher반환하거나 변화가 의존되어있을 때
    • 두개의 callback는 debugger event 반환함
watchEffect(
  () => {
    /* side effect */
  },
  {
    onTrigger(e) {
      debugger
    }
  }
)

watch

  • 구체적인 데이터 자원을 요구하고 각각의 콜백 함수에 단점이 적용된다
  • watched할 데이터가 변화가 있을때만 call 된다
  • 한개의 데이터
// watching a getter
const state = reactive({ count: 0 })
watch(
  () => state.count,
  (count, prevCount) => {
    /* ... */
  }
)

// directly watching a ref
const count = ref(0)
watch(count, (count, prevCount) => {
  /* ... */
})
  • 여러개 데이터 - array 이용
watch([fooRef, barRef], ([foo, bar], [prevFoo, prevBar]) => {
  /* ... */
})

'Vue.js > vue3' 카테고리의 다른 글

[vue3] Reactivity Utilities  (0) 2020.09.30
[vue3] composition API  (0) 2020.09.30
[vue3] setup  (0) 2020.07.02
[vue3] vue 2 > vue3  (0) 2020.07.02

+ Recent posts