728x90
반응형

세그먼트 트리를 이용하여 구간의 합을 빨리 찾는 문제를 설명하도록 하겠습니다. 이번 포스팅은 영상을 찍어봤는데, 처음이라 자연스럽지 못하지만 나름 열심히 설명하려 노력했습니다. 어색하더라도 양해해 주십시오.

이론설명

 


초기설정구현

    public static int init(int node, int start, int end) {
        if (start == end) {
            tree[node] = numbers[start];
        } else {
            int left = init(node*2, start, (start+end)/2);
            int right = init(node*2+1, (start+end)/2+1, end);
            tree[node] = left+right;
        }
        return tree[node];
    }


구간합 찾기 구현

    public static int query(int node, int start, int end, int a, int b) {
        if (a > end || b < start) {
            return 0;
        }
        if (a <= start && end <= b) {
            return tree[node];
        }
        int left = query(node*2, start, (start+end)/2, a, b);
        int right = query(node*2+1, (start+end)/2+1, end, a, b);
        return left + right;
    }

 

 

전체코드

import java.io.*;
import java.util.StringTokenizer;

public class Rsq {

    static int[] numbers;
    static int[][] questions;
    static int[] tree;

    public static int init(int node, int start, int end) {
        if (start == end) {
            tree[node] = numbers[start];
        } else {
            int left = init(node*2, start, (start+end)/2);
            int right = init(node*2+1, (start+end)/2+1, end);
            tree[node] = left+right;
        }
        return tree[node];
    }

    public static int query(int node, int start, int end, int a, int b) {
        if (a > end || b < start) {
            return 0;
        }
        if (a <= start && end <= b) {
            return tree[node];
        }
        int left = query(node*2, start, (start+end)/2, a, b);
        int right = query(node*2+1, (start+end)/2+1, end, a, b);
        return left + right;
    }

    public static void main(String[] args) throws IOException {

        System.setIn(new FileInputStream("input\\rsq.txt"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st = new StringTokenizer(br.readLine());

        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());

        numbers = new int[N];
        questions = new int[M][2];
        tree = new int[N*4];

        st = new StringTokenizer(br.readLine());
        for (int i=0; i<N; i++) {
            numbers[i] = Integer.parseInt(st.nextToken());
        }

        for (int i=0; i<M; i++) {
            st = new StringTokenizer(br.readLine());
            questions[i][0] = Integer.parseInt(st.nextToken());
            questions[i][1] = Integer.parseInt(st.nextToken());
        }

        br.close();

        init(1, 0, N-1);

        for (int i=0; i<tree.length; i++) {
            System.out.println("tree[" + i + "] : " + tree[i]);
        }

        for (int i=0; i<M; i++) {
            bw.write(query(1, 0, N-1, questions[i][0]-1, questions[i][1]-1)+"\n");
        }

        bw.flush();
        bw.close();
    }
}
[input : input\rsq.txt]
5 3
5 4 3 2 1
1 3
2 4
5 5
[output]
12
9
1
728x90
반응형
728x90
반응형

인접 리스트는 그래프 이론에서 그래프를 표현하기 위한 방법 중 하나입니다. 그래프의 한 꼭짓점에서 연결되어 있는 꼭짓점들을 하나의 연결 리스트로 표현하는 방법입니다. 인접 행렬에 비하여 변이 희소한 그래프에 효율적 입니다.

동작방식

아래와 같은 그래프가 존재할때 인접행렬을 만들어 보겠습니다. 1노드에서 시작하여 2,3 노드로 연결됩니다. 그리고 3노드는 2,4 노드로 연결됩니다. 이는 단방향을 나타내고 있음을 알수 있습니다. 2차원 배열을 준비하고 배열의 Y축을 시작 좌표, 배열의 X축을 그래프가 향하는 노드라고 생각을하고 아래 그림과 같이 만들어 사용을 합니다.

참고사이트

https://ko.wikipedia.org/wiki/%EC%9D%B8%EC%A0%91_%EB%A6%AC%EC%8A%A4%ED%8A%B8
 

인접 리스트 - 위키백과, 우리 모두의 백과사전

 

ko.wikipedia.org

 

기본코드

위 그래프를 만드는 방법과 간단히 순환하는 순서를 나타내는 코드입니다.

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;

public class Test {

    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

    static ArrayList<ArrayList<Integer>> alist = new ArrayList<ArrayList<Integer>>();

    static void run(int now)
    {
        System.out.print(now + " ");

        for (int i = 0; i<alist.get(now).size(); i++) {
            run(alist.get(now).get(i));
        }
    }

    public static void main(String[] args) throws IOException {        

        for (int i = 0; i < 5; i++) {
            alist.add(new ArrayList<>());
        }

        alist.get(1).add(2);
        alist.get(1).add(3);
        alist.get(3).add(2);
        alist.get(3).add(4);

        run(1);

        br.close();
        bw.close();        
    }
}

결과는 "1 2 3 2 4 "로 나타납니다.

728x90
반응형
728x90
반응형

PriorityQueue 는 우선순위가 가장 높은것을 빼는 규칙입니다.

 

동작방식

  1. 자료를 넣는다.
  2. 자료 삭제시 가장 우선순위 높은걸 삭제,
  3. 자료 읽을때 우선순위 가장 높은것을 읽는다.

시간복잡도

자료를 넣고 빼는 속도 모두 : logN

기본코드

PriorityQueue의 기본코드 입니다.

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Collections;
import java.util.PriorityQueue;


public class PriorityQueue_example_0 {

	/**
	 * Priority Queue - Heap 으로 가장 많이 구현되어있다.
	 *  - 먼저넣은 것중 우선순위가 높은 것을 뺀다.
	 *  - 자료를 넣고 빼는 속도 모두 : logN
	 *  - max, min 값 찾기에 많이 쓰임
	 */
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

	
    public static void main(String[] args) throws IOException {

        // min heap - 가장 위(0)가 가장 작은값 
        PriorityQueue<Integer> q = new PriorityQueue<Integer>();
        
        q.add(5);
        q.add(3);
        q.add(7);
        q.add(4);
        q.add(5);
        
        System.out.println(q.poll());
        System.out.println(q.poll());
        System.out.println(q.poll());
        System.out.println(q.poll());
        System.out.println(q.poll());
        System.out.println(q.poll());
        
        System.out.println("=======================");
        // max heap - 가장 위(0)가 가장 큰값 
        PriorityQueue<Integer> qr = new PriorityQueue<Integer>(Collections.reverseOrder());
        
        qr.add(5);
        qr.add(3);
        qr.add(7);
        qr.add(4);
        qr.add(5);
        
        // 빼지않고, 가장 우선순위 
        
        System.out.println(qr.poll()); // 가장 큰 하나를 제거하고 출력
        System.out.println(qr.poll()); // 가장 큰 하나를 제거하고 출력
        System.out.println(qr.poll()); // 가장 큰 하나를 제거하고 출력
        System.out.println(qr.poll()); // 가장 큰 하나를 제거하고 출력
        System.out.println(qr.poll()); // 가장 큰 하나를 제거하고 출력
        System.out.println(qr.poll()); // 가장 큰 하나를 제거하고 출력
        // --> 힙소트
        
		br.close();
		bw.close();

    }
}

결과는 다음과 같습니다.

3
4
5
5
7
null
=======================
7
5
5
4
3
null

 

아래는 class를 PriorityQueue에 넣어 우선순위를 조절해주어 실행해보는 코드입니다.

import java.io.IOException;
import java.util.PriorityQueue;

class Nodes implements Comparable<Nodes> {
    int a;
    int b;

    Nodes(int a, int b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public int compareTo(Nodes tar) {
        if (tar.a > this.a) return 1;
        if (tar.a < this.a) return -1;
        
        if(tar.b > this.b) return 1;
        if(tar.b < this.b) return -1;
        return 0;

    }

}

public class PriorityQueue_example_1 {
    public static void main(String[] args) throws IOException {

        PriorityQueue<Nodes> q = new PriorityQueue<Nodes>();

        q.add(new Nodes(1, 2));
        q.add(new Nodes(5, 1));
        q.add(new Nodes(5, 3));
        q.add(new Nodes(1, 2));
        q.add(new Nodes(4, 6));

        System.out.println(q.peek().a + " " + q.peek().b);
        q.poll();
        System.out.println(q.peek().a + " " + q.peek().b);
        q.poll();
        System.out.println(q.peek().a + " " + q.peek().b);
        q.poll();
        System.out.println(q.peek().a + " " + q.peek().b);
        q.poll();
        System.out.println(q.peek().a + " " + q.peek().b);
        q.poll();
    }
}

결과는 아래와 같습니다.

5 3
5 1
4 6
1 2
1 2

compareTo 함수를 오버라이드하여 class 내부적으로 순서를 조절하여 우선순위를 만들어 첫번째 숫자가 큰순, 두번째 수가 큰순으로 우선순위를 부여하여 큐에서 빼낸 결과입니다.

728x90
반응형
728x90
반응형

이번에는 슬라이딩 윈도우 알고리즘과 DAT 자료구조를 이용한 간단한 문제를 풀어보겠습니다.

 

문제

입력된 문자열(알파벳)에서 길이가 M개의 구간에서 가장 많이 등장하는 알파벳을 출력하라

문자열 : "AAAABBBBAABKKKABKKKKDKAAA"
M: 6

코드

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;


public class SlidingWindow_DAT {

	
	/**
	 * 슬라이등 윈도우 + DAT
	 */
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));


    public static void main(String[] args) throws IOException {        

        String str = "AAAABBBBAABKKKABKKKKDKAAA";
        int n = str.length();
        int m = 6;

        int[] dat = new int[100];

        //초기세팅 6개 DAT
        char maxCh = ' ';
        int maxCnt = 0;

        for (int i = 0; i<m; i++) {
            dat[str.charAt(i)]++;
            if (dat[str.charAt(i)] > maxCnt) {
                maxCnt = dat[str.charAt(i)];
                maxCh = str.charAt(i);
            }
        }

        //슬라이딩 윈도우
        for (int i = 0; i<n - m; i++) {            
            //다음 준비
            dat[str.charAt(i + m)]++;            
            dat[str.charAt(i)]--;    

            if (dat[str.charAt(i + m)] > maxCnt) {
                maxCnt = dat[str.charAt(i + m)];
                maxCh = str.charAt(i + m);
            }
        }

        System.out.println(maxCh);

        bw.close();
        br.close();
    }    

}

풀이

dat 배열에 길이가 M인 구간에서 나타나는 알파벳을 카운트하여 줍니다. 문자열 AAAABBBBAABKKKABKKKKDKAAA에서 처음 AAAABB 를 확인하면 dat 배열 dat['A']는 4, dat['B'] 는 2가 들어갑니다. 그리고 다음으로 이동합니다. 슬라이딩 윈도우 알고리즘으로 길이가 6인 구간을 기준으로 뒤문자는 카운트를 더해주고, 앞문자는 카운트에서 빼줍니다. 작업이 완려되면 dat배열에 문자번째와 max변수를 비교하여 max변수를 갱신합니다. 이러한 방식으로 M구간에서 가장 많이 나오는 알파벳을 알아낼 수 있습니다.

728x90
반응형
728x90
반응형

슬라이딩 윈도우 알고리즘은 배열 요소의 일정 범위 값을 비교할때 사용하면 유용한 알고리즘 입니다.

동작방식

일정 정수로 이루어진 배열 int[] arr= {3,1,5,3,4,1,5,7,5,1,8} 가 있다면, 길이가 5인 배열의 합계가 가장 큰 것은 무엇인가? 라는 문제에 사용될 수 있습니다. 일반적으로 아래와 같이 0번째 부터 4번째 (길이가 5이므로) 합을 구하고 저장합니다. 그리고 1번째 부터 5번째까지의 합을 구하고 저장후 처음에 구했던 값과 비교를 하여 큰것을 가지고 있습니다. 이렇게 반복을 하면 됩니다. 하지만 이 방법은 매번 for 루프로 모든 배열의 요소를 지정된 길이만큼 순회하며 합계를 구해 최대값을 구해야하므로 비효율적 입니다.

[3,1,5,3,4],1,5,7,5,1,8 ==> 합: 16, 최대값: 16
3,[1,5,3,4,1],5,7,5,1,8 ==> 합: 14, 최대값: 16
3,1,[5,3,4,1,5],7,5,1,8 ==> 합: 18, 최대값: 18 
...
==> 비효율적

이것을 간단히 생각해보면 처음에 해당 길이만큼 합계를 구하는 것은 어쩔수 없습니다. 하지만, 그 이후부터 매번 돌지 않고 인덱스 1~5까지의 합은 처음에 길했던 0~4까지의 합계에 0번째 배열의 값을 빼고, 5번째 배열의 값을 더한 값과 같습니다. 바로 이 부분에서 처음 구했던 0~4까지의 합계를 재사용하며 다음값을 구할 수 있는데, 이것이 슬라이딩 윈도우 알고리즘의 핵심입니다.

참고사이트

https://blog.fakecoding.com/archives/algorithm-slidingwindow/
 

[알고리즘] 슬라이딩 윈도우 알고리즘

슬라이딩 윈도우(Sliding Window) 알고리즘은 배열이나 리스트의 요소의 일정 범위의 값을 비교할때 사용하면 유용한 알고리즘이다. 예를들어 정수로 이루어진 배열 [2, 4, 7, 10, 8, 4, 5, 6, 7, 1] 에서 길

blog.fakecoding.com

기본코드

위 설명의 예제를 구현한 코드입니다.

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class SlidingWindow_example {
    static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));    

    static int[] arr= {3,1,5,3,4,1,5,7,5,1,8};
    static int n;

    static int getFive(int index)
    {
        int sum= 0;
        for (int i = 0; i<5; i++) {
            sum += arr[i + index];
        }
        return sum;
    }

    public static void main(String[] args) throws IOException {        

        n = arr.length;
        int max = -9999;

        int sum = getFive(0);

        for (int i = 0; i <= n - 5; i++) {
            if (sum > max) max = sum;

            // 마지막순간에는 다음 것을 준비할 필요 없음
            if (i == n - 5) break;

            // 다음 것을 준비
            sum += arr[i + 5];
            sum -= arr[i];
        }

        System.out.println(max);

        bw.close();
        br.close();
    }        
}

결과는 26이 나옵니다.

728x90
반응형
728x90
반응형

DAT는 자료구조입니다. 값을 배열의 index를 활용하는 것이 포인트 입니다. 

 

동작방식

배열을 사용하여 레코드를 해당 키에 매핑할 수 있는 데이터 구조입니다. 직접 주소 테이블에서 레코드는 키 값을 인덱스로 직접 사용하여 배치됩니다. 빠른 검색, 삽입 및 삭제 작업을 용이하게 합니다.

출처: https://www.geeksforgeeks.org/direct-address-table/

최대값에 1을 더한 크기의 배열을 만든 다음(0 기반 인덱스로 가정) 값을 인덱스로 사용합니다. 예를 들어 다음 다이어그램에서 키 21은 인덱스로 직접 사용됩니다.

시간복잡도

탐색,삽입,삭제 연산을 모두 O(1)

참고사이트

https://www.geeksforgeeks.org/direct-address-table/
 

Direct Address Table - GeeksforGeeks

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

www.geeksforgeeks.org

기본코드

아래는 글을 입력받아 가장 많이 나온 문자를 찾아내는 간단한 코드입니다.

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;


public class DAT_example {
	
	/**
	 * DTA : Direct Address Table 자료구조 
	 * ==> 값을 index로 활용하는 것인 포인트
	 */
	
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

	public static void main(String[] args) throws IOException  {
		
		// 입력
		String input = br.readLine();
		int[] arr = new int[200];
		int max = 0;
		String maxChar = "";
		for(int i=0; i<input.length(); i++){
			arr[input.charAt(i)] += 1;
			if(arr[input.charAt(i)]  > max){
				max = arr[input.charAt(i)] ;
				maxChar = input.charAt(i)+"";
			}
		}
		
		// 풀이
		System.out.println(maxChar);
		
		br.close();
		bw.close();
	}

}

결과

AMDKIDD   <== 입력
D              <== 결과
728x90
반응형
728x90
반응형

지난번 VMware에 CentOS Stream 8을 설치해 보았습니다. 이번에는 PostgreSQL13을 설치해 보도록 하겠습니다.

1. PostgreSQL 인스톨

dnf 명령을 실행하여 내장 PostgreSQ: 모듈을 비활성화 합니다.

[root@TypilerServer pgsql]# dnf -y module disable postgresql

PostgreSQL rpm 링크를 아래 사이트에서 찾아 링크 주소를 복사합니다.

https://yum.postgresql.org/repopackages/
 

Repo RPMs - PostgreSQL YUM Repository

9.4 RHEL 8 - x86_64, RHEL 7 - x86_64, RHEL 6 - x86_64, RHEL 6 - i386, RHEL 5 - x86_64, RHEL 5 - i386

yum.postgresql.org

CentOS 8-x86_64 링크에 마우스를 올리고 오른쪽 마우스 버튼을 클릭하여 링크 주소 복사합니다. 콘솔에 아래와 같이 명령어를 입력합니다. 

[root@TypilerServer ~]# yum -y install https://download.postgresql.org/pub/repos/yum/reporpms/EL-8-x86_64/pgdg-redhat-repo-latest.noarch.rpm

2. PostgreSQL 서버 패키지 설치

[root@TypilerServer pqsql]# yum -y install postgresql13-server

설치가 완료되면 postgres 계정이 생성된 것을 확인할 수 있습니다.

 

4. 데이터베이스 클러스트 작성

데이터 베이스 클러스트는 데이터 베이스를 저장하는 영역입니다.

[root@TypilerServer pgsql]# su - postgres -c '/usr/pgsql-13/bin/initdb -E UTF8'

5. 데이터베이스 기동

systemctl 을 이용해서 기동을 하려니 동작을 안합니다. 그래서 데몬에 postgresql-13.service 를 등록해 줍니다.

[root@TypilerServer ~]# systemctl daemon-reload
[root@TypilerServer ~]# systemctl enable postgresql-13.service

그리고 데몬을 실행해 봅니다.

[root@TypilerServer ~]# systemctl start postgresql-13.service
[root@TypilerServer ~]# systemctl status postgresql-13.service

정상적으로 구동이 완료되었습니다.

6. 상태확인

[postgres@TypilerServer ~]$ ps -ef | grep pgsql

6. test 데이터베이스 생성

postgres 계정으로 로그인한 뒤 test 데이터 베이스를 생성합니다. 

[postgres@TypilerServer ~]$ createdb test
[postgres@TypilerServer ~]$ psql test

생성 후 psql -l 로 데이터베이스 목록을 확인하면 아래와 같이 test가 추가 되었음을 알 수 있습니다.

 

지금까지 CentOS Stream 8 에 PostgreSQL 13 설치를 진행해 보았습니다. 예전에 설치를 했을때보다 확실히 간소화 되고 자동으로 설정을 진행해줘 설치에는 어려움이 없는것 같습니다. 아직 설정할 것이 남았는데 조금씩 진행해 보도록 하겠습니다. 

https://tylee82.tistory.com/33
 

RadHat9 - postgresql 설치 (성공)

############################################################# # # Title : postgresql 8.3.6 source version install for RadHat9 (Success) # date : 2009.02.26 # Lee Tae Young # ########################..

tylee82.tistory.com

 

728x90
반응형
728x90
반응형

 

Vue 사용 웹 앱을 개발하기 위해 알아야하는 페이지 이동 방법을 알아보도록 하겠습니다. 페이지 이동방법은 뷰 라우터라는 것이 있습니다. 뷰 라우터는 뷰에서 라우팅 기능을 구현할 수 있도록 지원하는 공식 라이프러리입니다. 이것을 이용하면 뷰로 만든 페이지간 간에 자유로운 이동이 가능해 집니다. 

[참고]
라우팅이란 ?
 웹 페이지 간의 이동방법, 싱글 페이지 애플리케이션에서 주로 사용, 화면전환이 매끄러움, 사용자 접근성 향상

뷰 라우터를 구현하는 태그는 아래와 같습니다.

<script src="https://unpkg.com/vue-router/dist/vue-router.js"> : 라우터 라이브러리
<router-link to="URL 값"> : 페이지 이동 태그
<router-view> : 페이지 표시 태그

직접 아래 예제를 확인해 보도록 하겠습니다.

<!DOCTYPE html>
<html lang="en" dir="ltr">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Vue Router Sample</title>
  </head>
  <body>
    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script src="https://unpkg.com/vue-router/dist/vue-router.js"></script>
    <div id="app">
      <h1>뷰 라우터 샘플</h1>
      <p>
        <!-- 1 : URL 값을 변경하는 태그 -->
        <router-link to="/foo">Foo 이동</router-link>
        <router-link to="/bar">Bar 이동</router-link>
      </p>
      <!-- 2 : URL 값에 따라 갱신되는 화면 영역 -->
      <router-view></router-view>
    </div>
    <script>
      // 3 : 컴포넌트 정의
      var Foo = { template: '<div>foo</div>'};
      var Bar = { template: '<div>bar</div>'};

      // 4 : 각 URL에 맞춰 표시할 컴포넌트 지정
      var routes = [
        { path:'/foo', component:Foo },
        { path:'/bar', component:Bar }
      ];

      // 5 : 뷰 라우터 정의
      var router = new VueRouter({
        routes
      });

      // 6 : 뷰 인스턴스에 라우터 추가
      var app = new Vue({
        router
      }).$mount('#app');

    </script>
  </body>
</html>

아래는 실행 결과입니다.

 

뷰 기본 라우팅 방식을 이용하여 페이지를 전환하는 예제입니다. 

  1. <router-link>는 화면 상에서 <a> 버튼 태그로 변환되어 표시됩니다. to="" 정의된 텍스트 값이 브라우저 URL 끝에 추가됩니다.
  2. <router-view>는 갱신된 URL에 해당하는 화면을 보여주는 영역입니다. 이곳에 나타낼 화면은 <script>에서 정의합니다.
  3. Foo, Bar 컴포넌트에는 template 속성으로 각 컴포넌트를 구분할 수 있는 정도의 HTML 코드를 정의합니다.
  4. routes 변수에는 URL 값이 /foo 일때 Foo 컴포넌트를, /bar 일때 Bar 컴포넌트를 표시하도록 정의합니다.
  5. router 변수에는 뷰 라우터를 생성하고, routes 를 삽입해 URL에 따라 화면이 전환될 수 있게 정의합니다.
  6. 새 인스턴스를 생성하고 라우터의 정보가 담긴 router를 추가합니다. 
$mount() API란?
el 속성과 동일하게 인스턴스를 화면에 붙이는 역할을 합니다. 인스턴스를 생성할 때 el 속성을 넣지 않아도 $mount()를 이용하면 강제로 인스턴스르 화면에 붙일 수 있습니다.

기본 코드에서는 컴포넌트 1개만 표시되기 때문에 간단합니다. 하지만 실제 구현은 화면에 여러개의 컴포넌트로 분할된 경우가 많습니다. 그럼 여러 개의 컴포넌트를 동시에 표시할 수 있는 라우터인 네스티드 라우터와 네임드 뷰 라는 두가지가 있습니다. 

 

네스티드 라우터

네스티드 라우터는 라우터로 페이지를 이동할 때 최소 2개 이상의 컴포넌트를 화면에 나타낼 수 있습니다. 상위 컴포넌트 1개에 하위컴포넌트 1개를 포함하는 구조로 구성됩니다. 아래와 같은 구조입니다.

출처: https://router.vuejs.org/kr/guide/essentials/nested-routes.html

네스티드 라우터를 이용하면 URL에 따라서 컴포넌트의 하위 컴포넌트가 다르게 표시됩니다. 

아래는 간단한 네스티드 라우터 코드입니다.

<!DOCTYPE html>
<html lang="en" dir="ltr">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Vue Nested Router Sample</title>
  </head>
  <body>
    <script src="https://unpkg.com/vue/dist/vue.js"></script>
    <script src="https://unpkg.com/vue-router/dist/vue-router.js"></script>
    <div id="app">
      <p>
        <router-link to="/user/foo">/user/foo</router-link>
        <router-link to="/user/foo/profile">/user/foo/profile</router-link>
        <router-link to="/user/foo/posts">/user/foo/posts</router-link>
      </p>
      <!-- 1 : User 컴포넌트가 뿌려질 영역 -->
      <router-view></router-view>
    </div>
    <script>
    // 2 : 컴포넌트의 내용 정의
      var User = {
        template: `
          <div class="user">
            <h2>User {{ $route.params.id }}</h2>
            <router-view></router-view>
          </div>
        `
      };
      const UserHome = { template: '<div>Home</div>' };
      const UserProfile = { template: '<div>Profile</div>' };
      const UserPosts = { template: '<div>Posts</div>' };

      // 3 : 네스티드 라우팅 정의
      var routes = [
          { path: '/user/:id', component: User,
            children: [
              // UserHome will be rendered inside User's <router-view>
              // when /user/:id is matched
              { path: '', component: UserHome },

              // UserProfile will be rendered inside User's <router-view>
              // when /user/:id/profile is matched
              { path: 'profile', component: UserProfile },

              // UserPosts will be rendered inside User's <router-view>
              // when /user/:id/posts is matched
              { path: 'posts', component: UserPosts }
            ]
          }
        ];

      // 4 : 뷰 라우터 정의
      var router = new VueRouter({
        routes
      });

      // 5 : 뷰 인스턴스에 라우터 추가
      var app = new Vue({ router }).$mount('#app')

    </script>
  </body>
</html>

아래는 실행 결과 입니다.

User 컴포넌트를 상위 컴포넌트로 놓고 URL에 따라 각각의 컴포넌트를 표시하는 코드입니다. 네스티드 라우터와 기본 라우터의 차이점은 최상위 컴포넌드에도 <router-view>가 있고, 최상위 컴포넌트의 하위 컴포넌트(User)에도 <router-view>가 있다는 것 입니다. 네스티드 라우터는 화면을 구성하는 컴포넌트의 수가 적을 때는 유용하지만 많은 컴포넌트를 표시하는데는 한계가 있습니다. 이것을 해결할 수 있는 방안이 네임드 뷰입니다.

 

네임드 뷰

네임드 뷰는 특정 페이지로 이동했을 때 여러 개의 컴포넌트를 동시에 표시하는 라우팅 방식입니다. 네스티드 라우터 방식은 상위 컴포넌트가 하위 컴포넌트를 포함하는 형식이지만, 네임드 뷰는 같은 레벨에서 여러 개의 컴포넌트를 한 번에 표시합니다.

<!DOCTYPE html>
<html lang="en" dir="ltr">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Vue Named View Sample</title>
  </head>
  <body>
    <script src="https://unpkg.com/vue/dist/vue.js"></script>
    <script src="https://unpkg.com/vue-router/dist/vue-router.js"></script>
    <!-- 1 : 라우팅 영역 정의 -->
    <div id="app">
      <router-view name="header"></router-view>
      <router-view></router-view>
      <router-view name="footer"></router-view>
    </div>

    <script>
      // 2 : 컴포넌트의 내용 정의
      var Body = { template: '<div>This is Body</div>'};
      var Header = { template: '<div>This is Header</div>'};
      var Footer = { template: '<div>This is Footer</div>'};

      // 3 : 네스티드 라우팅 정의
      var routes = [
          { path: '/', components: {
              default : Body,
              header : Header,
              footer : Footer
            }
          }
        ];

      // 4 : 뷰 라우터 정의
      var router = new VueRouter({
        routes
      });

      // 5 : 뷰 인스턴스에 라우터 추가
      var app = new Vue({ router }).$mount('#app')

    </script>
  </body>
</html>

아래는 실행 결과 입니다.

위 코드를 실행하면 URL 값 '/'에 의해 네임드 뷰가 바로 실행됩니다. 코드를 살펴보면 아래와 같습니다.

  1. <router-view>에 name 속성을 추가하는데 name 속성은 아래 components 속성에 정의하는 컴포넌트와 매칭하기 위한 속성입니다. name 속성이 없는 것은 default로 표시될 컴포넌트를 의미합니다.
  2. Body, Header, Footer 컴포넌트의 내용에 담길 객체를 선언합니다.
  3. 라우팅정보를 정의합니다.
  4. 뷰 라우터를 정의합니다.
  5. 뷰 인스턴스에 라우터를 추가합니다.

네임드 뷰를 활용하면 특정 페이지로 이동했을 때 해당 URL에 맞추어 여러 개의 컴포넌트를 한 번에 표시할 수 있습니다.

 

 

참고사이트

https://router.vuejs.org/kr/guide/#html
 

시작하기 | Vue Router

시작하기 Vue와 Vue 라우터를 이용해 싱글 페이지 앱을 만드는 것은 매우 쉽습니다. Vue.js를 사용한다면 이미 컴포넌트로 앱을 구성하고 있을 것입니다. Vue 라우터를 함께 사용할 때 추가로 해야하

router.vuejs.org

 

728x90
반응형
728x90
반응형

지난 포스트에 이어서 VMware에 CentOS Stream 8 을 설치하도록 하겠습니다. 지난 포스트는 아래를 참고하여 주십시오.

https://tylee82.tistory.com/311
 

[VMware] CentOS Stream 8 설치(1)

많은 고민 끝에 VMware에 설치할 OS 를 선정하였습니다. CentOS Stream 8 입니다. 우분투를 한번도 사용하지 않아서 설치를 해볼까 했는데, 아무래도 서버를 공부하기에는 우분투보다는 CentOS가 더 좋을

tylee82.tistory.com

 

설치는 간단하게 진행됩니다. 각자 사용목적에 맞게 설치를 진행하면 되며, 요즘 나오는 리눅스는 자동화가 잘 되어있을거라 생각하여 간단한 설정만 하고 설치를 진행하였습니다. 그리고 나중에 필요한건 추가로 설치를 하도록 하겠습니다.

CentOS Stream 8 설치 과정

1. VMware 의 상단 메뉴에 플레이 버튼으로 앞에서 작성된 CentOS Stream 8 가상머신을 구동합니다.

2. 설치를 위하여 "Install CentOS Stream 8-stream" 을 선택하여 엔터를 누릅니다.

3. 설치 마법사 화면이 아래와 같이 나타나며, 언어를 선택하여 줍니다.

4. 설치에 대한 요약을 살펴보고 필요한 부분의 설정을 시작합니다.

4-1. 소프트웨어 선택입니다. 저는 서버로 사용을 할 목적으로 만드는 것이라, 기본환경은 서버입니다. 그리고 추가 소프트웨어는 "FTP서버" 와 "개발용 툴" 정도만 선택을 하고 완료를 눌러주었습니다. 나중에 필요한 부분이 있으면 설치를 할 수 있습니다.

4-2. 설치 목적은 "자동설정"을 사용하였습니다.

4-3. root 계정의 암호를 설정하여 줍니다.

4-4. 사용자를 생성하여줍니다. 저는 새로 생성된 사용자를 관리자로 지정하였습니다.

4-5. 네트워크 설정을 진행합니다. 간단하게 이더넷을 켬으로 바꾸니 아래와 같이 설정됩니다. 그리고 Host Name은 이곳에서 변경이 가능합니다.

4-6. 시간대를 설정하여 줍니다.

5. 모든 설정이 완료되었으면 "설치 시작" 버튼을 클릭하여 설치를 진행합니다. 설치가 완료되면 "시스템 재시작" 버튼을 눌러 재시작하여 줍니다.

6. 재시작 후 아래와 같이 터미널이 나타나며, 생성한 계정으로 로그인을 할 수 있습니다.

설치를 마치며

예전에 제가 CentOS5 버전을 설치하는 글이 있었습니다. 

참고 : 2009.06.15 - [Programe Note/OS] - [CentOS5.2] Install

저도 오랫만에 새로운 버전으로 설치를 진행하였는데, 전보다 더 간편해지고 크게 어려운 부분은 없습니다. 일단 사용을 하면서 필요한 것들은 설치를 하고, 혹시 다시 재install을 진행한다면 이곳에 변경되는 부분을 남기도록 하겠습니다. Stream 버전이라고해서 크게 달라진 부분이 많은 것 같지 않아, 개인 서버로 사용할 사용자에게는 CentOS7 혹은 8보다는 최신 버전이 나을것 같다는 개인적인 생각입니다.

728x90
반응형
728x90
반응형

클로저란?

내부 함수가 정의될 때 외부 함수의 환경을 기억하고 있는 내부 함수를 말합니다. 외부 함수 안에서 선언된 내부 함수는 그 외부 함수의 지역 변수가 함수에 접근하여 사용할 수 있습니다. 클로저는 Javascript 고유개념은 아닙니다. 함수를 일급 객체로 취급하는 함수형 프로그래밍 언어에서 사용되는 특징중에 하나입니다. 그래서 ECMAScript 명세에 클로저의 정의는 없다고 합니다. MDN에서는 아래와 같이 정의를 하고 있습니다.

“A closure is the combination of a function and the lexical environment within which that function was declared.”
클로저는 함수와 그 함수가 선언됐을 때의 렉시컬 환경(Lexical environment)과의 조합이다.

역시나 말이 어렵습니다. 간단하게 다시 설명을 하면, 자바스크립트의 함수는 일종의 객체입니다. 그래서 다른 객체와 같이 임의의 키를 추가가 가능합니다. 클로저는 함수를 구성하는 코드와 함수가 생성될 당시의 스코프 환경(공식적으로 위에서 설명한 렉시컬 환경)으로 구성됩니다. 클로저는 스코프 환경을 알고 있기 때문에, 함수가 생성될 당시의 모든 변수를 기억해 두었다가 함수가 호출될 때 사용할 수 있습니다.

사용이유

클로저는 자바스크립트의 강력한 기능으로 비록 메모리 차원에서 손해를 볼 수 있긴하지만, 적극적으로 사용해야합니다. 아래의 이유로 사용을 할 수있습니다.

  1. 상태유지: 현재 상태를 기억하고 변경된 최신 상태를 유지할 수 있다.
  2. 전역 변수의 사용 억제: 상태 변경이나 가변 데이터를 피하고 오류를 피하는 안정성을 증가 시킬수 있다.
  3. 정보의 은닉: 클래스 기반 언어의 private 키워드를 흉내낼 수 있다.

각각의 예제는 아래 사이트를 통해서 확인 가능합니다.

https://poiemaweb.com/js-closure
 

Closure | PoiemaWeb

클로저(closure)는 자바스크립트에서 중요한 개념 중 하나로 자바스크립트에 관심을 가지고 있다면 한번쯤은 들어보았을 내용이다. execution context에 대한 사전 지식이 있으면 이해하기 어렵지 않

poiemaweb.com

 

 

참고사이트

https://hyunseob.github.io/2016/08/30/javascript-closure/
 

JavaScript 클로저(Closure)

클로저란?MDN에서는 클로저를 다음과 같이 정의하고 있다. 클로저는 독립적인 (자유) 변수를 가리키는 함수이다. 또는, 클로저 안에 정의된 함수는 만들어진 환경을 ‘기억한다’. 흔히 함수 내

hyunseob.github.io

https://developer.mozilla.org/ko/docs/Web/JavaScript/Closures
 

클로저 - JavaScript | MDN

클로저는 함수와 함수가 선언된 어휘적 환경의 조합이다. 클로저를 이해하려면 자바스크립트가 어떻게 변수의 유효범위를 지정하는지(Lexical scoping)를 먼저 이해해야 한다.

developer.mozilla.org

https://tislwlstnf.tistory.com/8
 

클로저의 의미와 사용하는 이유

클로저란? 클로저는 내부 함수가 정의될 떄 외부 함수의 환경을 기억하고 있는 내부 함수를 말합니다. 외부 함수 안에서 선언된 내부 함수는 그 외부 함수의 지역 변수나 함수에 접근하여 사용

tislwlstnf.tistory.com

https://medium.com/sjk5766/javascript-closure%EB%8A%94-%EC%99%9C-%EC%93%B8%EA%B9%8C-81bcdef6352
 

JavaScript Closure는 왜 쓸까?

쬐끔 알고 있던 Closure를 최근에 좀 더 알게 되었고, 음.. 근데 언제? 무슨 이유로 개발할 때 Closure를 쓸까 궁금해서 찾아보게 되었습니다. 검색해서 찾은 여러 글 들 중에 고개를 끄덕거린 답변을

medium.com

 

728x90
반응형

+ Recent posts