<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
    <channel>
        <title>be-quiet_h.log</title>
        <link>https://velog.io/</link>
        <description>Progress Gradually, Never Stop</description>
        <lastBuildDate>Tue, 18 Apr 2023 02:31:09 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>https://github.com/jpmonette/feed</generator>
        <image>
            <title>be-quiet_h.log</title>
            <url>https://velog.velcdn.com/images/be-quieth/profile/e72cbccd-116b-469d-83f8-0ef55e156e1a/social_profile.jpeg</url>
            <link>https://velog.io/</link>
        </image>
        <copyright>Copyright (C) 2019. be-quiet_h.log. All rights reserved.</copyright>
        <atom:link href="https://v2.velog.io/rss/be-quieth" rel="self" type="application/rss+xml"/>
        <item>
            <title><![CDATA[23.04.18 Vue & Git]]></title>
            <link>https://velog.io/@be-quieth/23.04.18-Vue-Git</link>
            <guid>https://velog.io/@be-quieth/23.04.18-Vue-Git</guid>
            <pubDate>Tue, 18 Apr 2023 02:31:09 GMT</pubDate>
            <description><![CDATA[<p>MacOS, SourceTree, GitHub, IntelliJ 기준</p>
<ol>
<li><p>git(원격)에 Repository 생성</p>
</li>
<li><p>자신이 원하는 위치에 로컬 파일 폴더 생성</p>
</li>
<li><p>터미널에서 cd ~ 를 통해 방금 생성한 로컬 파일 경로로 이동</p>
</li>
<li><p>git init 명령어를 통해 깃 연동을 위한 폴더로 활성화</p>
</li>
<li><p>1번에서 git Repository에 README.md 라는 파일을 만들어놓은 게 있으므로 터미널에서 git pull origin main 을 통해 해당 파일을 받아와 원격 저장소와 로컬 저장소를 synchronize한다.</p>
</li>
<li><p>그리고나서 자신이 원하는 파일을 만든다. 필자와 같은 경우 Vue 프로젝트를 생성했으며 이 과정에서 참고한 레퍼런스는 다음과 같다.
참고 : <a href="https://developer.mozilla.org/ko/docs/Learn/Tools_and_testing/Client-side_JavaScript_frameworks/Vue_getting_started">https://developer.mozilla.org/ko/docs/Learn/Tools_and_testing/Client-side_JavaScript_frameworks/Vue_getting_started</a></p>
</li>
<li><p>이렇게 만들고나면 로컬 저장소가 원격 저장소와 원래 README.md(원격에서 만들었던)가 같이 있어 동기화되어 있었는데 로컬에 vue 프로젝트 구조가 들어섬에 따라 커밋할 거리가 생긴다.</p>
</li>
<li><p>이 변경 사항들에 대해 git add --all 을 사용한다. 과거 우아한 테크코스(프리코스) 에서 배울 때는 깃에서 관리할 파일들에 대해 어느정도 판단을 한 후에 선택하라고 했었다. 하지만 필자는 아직 그 정도의 판단을 내리기엔 지식이 부족한 것 같아 우선은 위 명령어를 사용했다.</p>
</li>
<li><p>git add --all 을 통해 변경된 파일들에 대해 스테이지에 올린 후 git commit -m &quot;아무말&quot; 로 커밋해주면 로컬의 선택된 변경파일들이 &quot;로컬&quot;에 저장된 상태가 된다.</p>
</li>
<li><p>이렇게 로컬에 저장된 파일들을 이제 원격에 올려야 한다.
git push origin main 을 통해 원격 저장소에 올리자.</p>
<blockquote>
<p>여기서 주의할 점이 있다.
필자의 경우 SourceTree를 통해 작업하는 것에 익숙하여 이를 활용하고자 했으나, 소스트리에서 커밋한 변경파일들을 push하려고 하면 깃헙 Authentification을 위한 아이디, 비밀번호를 입력하는 과정을 거치는데, 계속해서 오류가 뜬다. 비밀번호가 잘못 입력되었나 싶어 Mac 기능인 &quot;키체인 접근.app&quot;을 통해 sourceTree에 저장된 Authentification 파일을 삭제하고 재시도를 여러번 해보았으나 에러 문구를 읽어보니 소스트리에서는 비밀번호를 통한 인증 방식이 예전에 폐쇄되었다고 한다. 결국 IntelliJ에서 터미널로 직접 git push origin main을 했다.</p>
</blockquote>
</li>
</ol>
<p>이게 끝이다. 이렇게 해서 로컬과 원격의 연동 여부를 재검토해보자.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[23.03.21 Vue]]></title>
            <link>https://velog.io/@be-quieth/23.03.21-Vue</link>
            <guid>https://velog.io/@be-quieth/23.03.21-Vue</guid>
            <pubDate>Tue, 21 Mar 2023 07:42:08 GMT</pubDate>
            <description><![CDATA[<h2 id="introduction">Introduction</h2>
<h3 id="vue의-특성">vue의 특성</h3>
<ul>
<li>Declarative Rendering</li>
<li>Reactivity</li>
</ul>
<h3 id="single-file-components">Single-File Components</h3>
<ul>
<li>JS(&lt;script&gt;), HTML(&lt;template&gt;), CSS(&lt;style&gt;) 소스들이 하나의 파일에 저장되어있는 양식</li>
</ul>
<h3 id="vue-components-can-be-authored-in-two-different-api-styles">Vue components can be authored in two different API styles</h3>
<ol>
<li><p>Options API</p>
<ul>
<li><p>data, methods, mounted와 같은 options의 객체들을 사용해서 컴포넌트의 로직을 정의하는 스타일이다.</p>
</li>
<li><p>options에 의해 정의된 속성들은 함수들 안에서 <code>this</code> 접근자(컴포넌트 인스턴트를 가리키게 해주는)로 접근 가능하다.</p>
<pre><code class="language-jsx">&lt;script&gt;
export default {
// data()로 리턴된 값은 reactive 상태가 된다.
// 그리고 &#39;this&#39; 접근자로 접근 가능하다.
data() {
  return {
    count: 0
  }
},

// methods는 상태를 변경하고 업데이트를 발생시키는 함수들이다.
// templates(html)에서 이벤트 리스너로 바인딩할 수 있다.
methods: {
  increment() {
    this.count++
  }
},

// Lifecycle hooks는 컴포넌트의 생명주기의 각 스테이지에 따라 호출된다. 아래 예시와 같은 경우엔 컴포넌트가 mounted된 후에 호출될 것이다..
mounted() {
  console.log(`The initial count is ${this.count}.`)
}
}
&lt;/script&gt;

&lt;template&gt;
&lt;button @click=&quot;increment&quot;&gt;Count is: {{ count }}&lt;/button&gt;
&lt;/template&gt;</code></pre>
</li>
</ul>
</li>
<li><p>Composition API.</p>
<ul>
<li><p>import한 API 함수들을 사용해서 컴포넌트의 로직을 정의하는 스타일이다. SFC에서는 &lt;script setup&gt; ~ &lt;/script&gt; 안에 해당 스타일을 구현한다. <code>setup</code> 속성은 보다 적은 코드량과 컴파일 하는데 걸리는 시간으로 Composition API를 사용할 수 있게 해준다. 예를 들어, &lt;script setup&gt;에서 선언된 imports와 상위 레벨 변수들, 함수들은 template에서 바로 사용이 가능하다.</p>
<pre><code>&lt;script setup&gt;
import { ref, onMounted } from &#39;vue&#39;

// reactive state
const count = ref(0)

// functions that mutate state and trigger updates
function increment() {
count.value++
}

// lifecycle hooks
onMounted(() =&gt; {
console.log(`The initial count is ${count.value}.`)
})
&lt;/script&gt;

&lt;template&gt;
    &lt;button @click=&quot;increment&quot;&gt;Count is: {{ count }}&lt;/button&gt;
&lt;/template&gt;
### 둘 중 어떤 스타일을 골라야 하는가?
사실 Options API는 Composition API의 최상위 계층에서 구현된 방식이다. 결국 기본적인 개념과 컨셉은 공유한다는 의미이다. 실제로 composition의 방식을 살펴보자. vue로부터 ref, onMounted를 import한다고 선언했으며 이 덕분에 위에서 설명한 장점대로 &#39;directly usable&#39;해졌다. 그리고 const타입의 count를 ref(0)으로 선언함으로서 reactive 상태로 만들었다. 아직 onMounted가 vue의 라이프사이클에서 어떤 주기를 차지하는지 모르지만 이 시기를 거칠때마다 console창에는 초기 카운트가 얼마라는 문자열이 찍힐 것이다.
</code></pre></li>
</ul>
</li>
</ol>
<p>Count is: ~~ 라는 버튼을 클릭할 때마다 Increment 함수가 실행될 것이며(Composition API의 장점) reactive state가 된 count가 increment 함수에 의해 1씩 증가되고, 이는 {{ count }} 에 반영되어 나타나진다. 개발자도구를 통해 onMounted()의 역할을 살펴보면, 콘솔창에는 &quot;The initial count is 0&quot; 라고 한번만 나타나진다. 즉, onMounted는 컴포넌트의 완전한 초기 구성이 이루어지고난 후에는 이미 끝난 상태임을 추측해볼 수 있다.</p>
<p>결론적으로, Options API는 조금 더 객체지향적인 느낌이 난다. 그야말로 options들의 구성 요소들을 중점적으로 챙기는 느낌이다. Composition API는 그야말로 &#39;대체&#39;라는 성격에 초점을 둔 느낌이다. setup 초반부에 필요한 속성들을 가져온 후 이를 순서 상관 없이(?) 선언하는 것 같다. 결국 객체지향과 절차지향의 느낌...이 강한데... 객체지향이 절차지향 이후에 나온 클린코드를 위한 스텝인 것을 생각해보면, 왜 vue 홈페이지에서 Options API를 Composition API의 top에서 구현된 것이며, 기본 컨셉과 지식은 같다고 하는지 이해가 대충 간다.</p>
<p>바로 다음 문단에 관련 글이 나온다.</p>
<p>&quot;Options API는 컴포넌트 인스턴스의 개념에 초점을 맞췄다. 주로 객체지향 프로그래밍과 밀접한 관련이 있다.&quot; 라고 한다.</p>
<p>Composition API는 함수 스코프에서 reactive state 변수들을 직접적으로 선언하고, 복잡도를 컨트롤하기 위해 다중 변수들로부터 단계를 묶어 형성하는 것에 초점을 맞춘다. 이는 더 자유로운 작업을 할 수 있도록 해주기 때문에 reactivity가 어떻게 작동하는지 잘 이해하는지 알아야 더욱 효과적인 vue작업이 가능하다. 또한, 이러한 융통성덕에 로직의 설계와 재사용에 더욱 강력한 장점을 가진다.</p>
<ul>
<li>Introduction fin -</li>
</ul>
<p>⚠️해당 글은 개발 입문 초보자의 시점에서 작성한 글이며, 잘못된 지식이 들어있을 수도 있습니다. 각종 견해와 조언, 반박 모두 환영합니다!⚠️</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[Vue.js Study day 1]]></title>
            <link>https://velog.io/@be-quieth/Vue.js-Study-day-1</link>
            <guid>https://velog.io/@be-quieth/Vue.js-Study-day-1</guid>
            <pubDate>Tue, 24 Jan 2023 06:41:18 GMT</pubDate>
            <description><![CDATA[<h2 id="declarative-rendering">Declarative Rendering</h2>
<p>직역하자면, template 라는, HTML을 확장한 구문을 사용함으로서 HTML이 JavaScript코드를 기반으로 어떻게 노출되어야 하는지를 설명해줄 수 있게끔 해주는 특성을 말한다. 이때 HTML은 자동으로 업데이트된다.</p>
<pre><code>&lt;script&gt;
export default {
  data() {
    return {
      message: &#39;Hello World!&#39;,
      counter: {
        count: 0
      }
    }
  }
}
&lt;/script&gt;

&lt;template&gt;
  &lt;h1&gt;{{ message }}&lt;/h1&gt;
  &lt;p&gt;Count is: {{ counter.count }}&lt;/p&gt;
&lt;/template&gt;</code></pre><p>코드를 살펴본 후 의역을 해보자.
우선 script언어로 상단에서 표현을 한 것이 보인다.
Data는 데이터의 변화에 따른 반응을 업데이트하여 객체로 반환하는 함수라고 한다. 정의에 맞게 함수형 선언을 하였고, 곧바로 return을 해주고 있다.</p>
<p>return으로는 message, counter(object:property - count)라는 property를 가진 객체를 반환하고 있다.</p>
<p>그렇게 script문은 끝이 났다. 이번엔 template 태그 내부를 살펴보자.</p>
<p>HTML언어로 쓰였는데, h1태그 안에 &#39;{{}}&#39; 표현이 쓰인 것을 볼 수 있다. 그리고 그 안에는 data() 함수의 리턴 객체중 message를 호출하고 있다.
-&gt; <strong>template안에서 data() property를 사용하기 위해서는 {{}} (mustaches syntax)를 사용해야 한다.</strong></p>
<p>{{}} 안의 내용물은 JS expression 사용이 가능하다.</p>
<pre><code>&lt;h1&gt;{{ message.split(&#39;&#39;).reverse().join(&#39;&#39;) }}&lt;/h1&gt;</code></pre><p>&lt;p&gt;문 안에 counter.count를 보면 객체의 property 호출 방식도 크게 벗어나지 않는 다는 것을 알 수 있다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[CSS]]></title>
            <link>https://velog.io/@be-quieth/CSS</link>
            <guid>https://velog.io/@be-quieth/CSS</guid>
            <pubDate>Sun, 22 Jan 2023 11:44:35 GMT</pubDate>
            <description><![CDATA[<h1 id="css">CSS</h1>
<p>Cascading Style Sheets</p>
<hr>
<ul>
<li>결국 <strong>Selector</strong>와 <strong>Property</strong>를 공부하는 것이 전부<ul>
<li>Selector<ol>
<li>일반 태그 : element 선택자</li>
<li>class : .~ → 다수를 그룹핑하여 구분짓는 태그</li>
<li>id : #~ → 1개를 구분짓는 태그</li>
<li>id &gt; class &gt; 일반 순으로 우선순위</li>
</ol>
</li>
</ul>
</li>
<li><a href="http://caniuse.com">caniuse.com</a></li>
</ul>
<style> ~ </style> : html의 문법이면서 동시에 이 태그 안쪽의 내용은 CSS 언어의 문법에 맞게 처리하라는 뜻

<pre><code class="language-css">1. 선택자 O 
&lt;style&gt;
  a { // a {~} : &#39;선택자(Selector)&#39;
        color:red; // &#39;declaration&#39;(color : property / red : value)
    }
&lt;/style&gt;

2. 선택자 X
&lt;a href=&quot;~~&quot; style=&quot;color:red&quot;&gt; // style은 html의 속성이며, style안으로 CSS 설명이 들어온다.</code></pre>
<pre><code class="language-css">&lt;style&gt;
.saw { // class가 saw인 태그를 가리키는 명령어
    color:gray;
}
#active {
    color:red;
}
&lt;/style&gt;

&lt;a href=&quot;~&quot; class=&quot;saw&quot;&gt;~~&lt;/a&gt;
&lt;a href=&quot;~&quot; class=&quot;saw&quot;&gt;~~&lt;/a&gt;
&lt;a href=&quot;~&quot; class=&quot;saw&quot; id=&quot;active&quot;&gt;~~&lt;/a&gt;</code></pre>
<ul>
<li>id 선택자와 class 선택자중에는 id선택자가 우선순위이다.</li>
<li>class 선택자는 태그 선택자보다 우위이다.</li>
</ul>
<p>element는 block level element, inline element로 나눠진다.</p>
<ol>
<li>block level : ex) h1같은 제목태그는 블록 단위로 부피를 차지한다.</li>
<li>inline : ex) a 태그 같은 것들은 자신의 글 만큼의 부피를 차지한다.</li>
<li>display의 기본 속성이다. → block이나 inline으로 조절 가능</li>
</ol>
<pre><code class="language-css">h1{
    display : inline // 원래 block인데 inline으로 바꾼 경우
}

a{
    display : block // 원래 inline인데 block으로 바꾼 경우
}</code></pre>
<pre><code class="language-css">h1 {
    border-width:5px;
    border-color:red;
    border-style:solid;
    border:5
}
a {
    border-width:5px;
    border-color:red;
    border-style:solid;
    border:5
}
--------------------
h1, a {
    border:5px solid red; // 위와 같다.
}</code></pre>
<ul>
<li><p>박스모델 (검색어 : css box model)</p>
<ul>
<li>content → padding → border → margin 순으로 둘러싸임.</li>
<li>개발자도구에서 elements창 → Styles 를 보면 CSS 코드를 볼 수 있다.</li>
</ul>
</li>
<li><p>Grid</p>
<ul>
<li><div> : block level division을 위한 용도로 쓰는 무색무취 태그 - 공간을 차지 → 줄바꿈이 되는 태그</li>
<li><span> : inline level division을 위한 … - 줄바꿈이 안되는 태그</li>
</ul>
</li>
<li><p>선택자 추가정보</p>
<pre><code class="language-css">  #grid ol { // grid 안의 ol을 지정하는 선택자.
      ~
  }

  &lt;div id=&quot;grid&quot;&gt;
      &lt;ol&gt;
      ...
      &lt;/ol&gt;
  &lt;/div&gt;
  &lt;ol&gt; ~ &lt;/ol&gt;</code></pre>
</li>
<li><p>반응형 웹디자인(Media Query)</p>
<pre><code class="language-css">  &lt;style&gt;
      div{
          ~
      }
      @media(max-width:800px) { // 800픽셀 이상부터는 display가 none!
          div{
              display:none;
          }
      }
  &lt;/style&gt;</code></pre>
</li>
<li><p>CSS 코드를 개별 파일로 저장함으로서 재사용성을 높인다.</p>
<ul>
<li>캐시라는 기능을 통해 파일이 별도로 바뀌지 않는 한 CSS 파일은 로컬 컴퓨터에 저장되어 효율이 매우 높아진다.</li>
</ul>
</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[JSON]]></title>
            <link>https://velog.io/@be-quieth/JSON</link>
            <guid>https://velog.io/@be-quieth/JSON</guid>
            <pubDate>Sun, 22 Jan 2023 11:43:38 GMT</pubDate>
            <description><![CDATA[<h1 id="json">JSON</h1>
<p>JavaScript Object Notation</p>
<hr>
<p>서버에서 클라이언트로 데이터를 보낼 때 사용하는 양식
JSON은 속성-값 쌍 (attribute–value pairs), 배열 자료형(array data types) 또는 기타 모든 시리얼화 가능한 값(serializable value) 또는 &quot;키-값 쌍&quot;으로 이루어진 데이터 오브젝트를 전달하기 위해 인간이 읽을 수 있는 텍스트를 사용하는 개방형 표준 포맷이다. 비동기 브라우저/서버 통신 (AJAX)을 위해, 넓게는 XML(AJAX가 사용)을 대체하는 주요 데이터 포맷이다. 특히, 인터넷에서 자료를 주고 받을 때 그 자료를 표현하는 방법으로 알려져 있다. 자료의 종류에 큰 제한은 없으며, 특히 컴퓨터 프로그램의 변수값을 표현하는 데 적합하다.</p>
<h2 id="자료구조">자료구조</h2>
<ul>
<li>Number</li>
<li>String</li>
<li>Boolean</li>
<li>Array</li>
<li>Object<ul>
<li>순서가 없는 이름/값 쌍의 집합. {}로 표현.</li>
<li>이름 : key(무조건 string → 따옴표 사용), 값 : value</li>
<li>{&quot;name2&quot;: 50, &quot;name3&quot;: &quot;값3&quot;, &quot;name1&quot;: true}</li>
</ul>
</li>
<li>null</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[AJAX]]></title>
            <link>https://velog.io/@be-quieth/AJAX</link>
            <guid>https://velog.io/@be-quieth/AJAX</guid>
            <pubDate>Sun, 22 Jan 2023 11:40:40 GMT</pubDate>
            <description><![CDATA[<p>AJAX
Asynchronous Java And XML
고정적인 내용과 변동성이 있는 내용을 구분하여 웹페이지의 성능을 향상시키는 방식
변동성이 있는 내용 → ajax파일화
Ajax를 구현하는 여러 방법중 Fetch API를 사용해보자.
Fetch API
<input type="button" value="fetch" onclick="
fetch('css.html').then(function (response) { // 익명함수 형태
    response.text().then(function (text) {
        alert(text);
        document.querySelector('article').innerHTML = text;
    })
})"></p>
<p>// fetch를 통해 정보를 요청하면 그 아래 명령어들을 실행함</p>
<p>fetch(<del>).then(function(response객체) {
}); // function을 호출할 때 첫번째 인자로 response객체를 주게 되어 있다.
response
fetch(</del>).then(function(response객체){};
fetch를 통해 요청했을 때 웹서버가 응답한 결과를 담은 객체이다.
<!doctype html></p>
<html>
<head>
  <title>WEB1 - Welcome</title>
  <meta charset="utf-8">
  <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
  <script src="colors.js"></script>
</head>
<body>
  <h1><a href="index.html">WEB</a></h1>
  <input id="night_day" type="button" value="night" onclick="
    nightDayHandler(this);
  ">
  <ol>
    <li><a onclick="fetchPage('html')">HTML</a></li>
    <li><a onclick="fetchPage('css')">CSS</a></li>
    <li><a onclick="fetchPage('javascript')">JavaScript</a></li>
  </ol>
<article>

</article>
<script>
  function fetchPage(name) {
    fetch(name).then(function (response) {
      response.text().then(function (text) {
        document.querySelector('article').innerHTML = text;          
      }) 
    })
      } // 인자로 name -> 요청한 결과 인자에 대한 text값을 받음 -> 인자로 text를 넣어 current
// document 내 article query를 선택하여 안에 text를 대입
</script>
</body>
</html>
Hash
hash값(북마크 기능)에 따라 ajax로 다른 페이지를 로드해서 시작되는 페이지를 세팅할 수 있다.
hash : url 파라미터와 비슷한 역할을 한다. #~를 하면 id를 찾아준다.
#은 기본적으로 북마크 기능이기 때문에 hash기능과 구분하기 위해 !(bang)을 붙여준다.
→ #! = hash bang
검색엔진 최적화가 잘 안됨 → Pjax를 쓰는 추새
계속해서 추상화를 해나가야 한다.
데이터와 API를 계속해서 구분해주어야 API의 유지 및 보수가 깔끔해진다.
Fetch API Polyfill
오래된 브라우저에도 Fetch api를 적용할 수 있는 api
]]></description>
        </item>
        <item>
            <title><![CDATA[JQuery]]></title>
            <link>https://velog.io/@be-quieth/JQuery</link>
            <guid>https://velog.io/@be-quieth/JQuery</guid>
            <pubDate>Sun, 22 Jan 2023 11:40:16 GMT</pubDate>
            <description><![CDATA[<p>JQuery
Element를 선택하는 강력한 방법과 
선택된 Element들을 효율적으로 제어할 수 있는 다양한 수단을 제공하는
JS Library
HTML에서 태그(Tag)와 요소(Element)는 대부분 구별없이 사용한다. 허나 정확하게 구별하는 것이 좋은 듯 하다. 태그(Tag)는 단지 열기 태그와 닫기 태그 그 자체를 의미하며 요소(Element)는 해당 태그와 그 내용(자식)을 포함한 전체를 의미한다.
JQuery를 삽입하는 방법
JQuery 소스 다운로드
링크 복사해서 적용
문법
$(제어대상).method1(0.method2();
$(제어대상) : 주어
method1(). ~ : 서술어
$(&#39;.anyClass&#39;).html(&#39;hello!&#39;);
메소드 체이닝이 가능하다.
인간의 문법과 비슷하다.
Wrapper : jQuery(element object|’CSS style 선택자’) ( = $(element object|’CSS style 선택자’))
jQuery로 wrap함으로서 인자로 전달된 요소들에 jQuery의 기능성을 부가해서 반환 가능.
$를 사용할 경우 외부 라이브러리와의 충돌을 피하기 위해 jQuery라는 이름을 쓰거나 함수의 인자로 $를 선언해주기도 한다.</p>
<ul>
  <li>test2</li>
</ul>
<ul class="foo">
  <li>test</li>
</ul>
<script type="text/javascript">
  (function ($) {
    $('ul.foo').click( function() { // ul.foo element가 click되면 function 실행
      $('li', this).css('background-color', 'red'); // func : li태그들에 대해 css 기능으로 배경을 red로 설정.
    }); // this : context, 생략 가능 이 이벤트를 발생시킨 element가 this -> ul.foo
  })(jQuery) // 따라서 this는 ul.foo 안의 li를 찾게 된다.
</script>
자바의 스트림같은 느낌
Chaining → Traversing
$(~).method1.methode2. ~ .end()
end() 메소드를 호출함으로서 다시 엘리멘트 객체를 가리키게 된다.
선택자
jQuery wrapper에는 CSS 선택자가 위치할 수 있는데, 이를 통해서 제어하려는 엘리먼트를 빠르고 정확하게 지정할 수 있다.
Event
클릭, 마우스 이동, 타이핑, 페이지 로딩등
<html>
    <head>
        <script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.6.2/jquery.min.js"></script>
        <script type="text/javascript">
            function clickHandler(e){
                alert('thank you');
            }
            $(document).bind('ready', function(){ // ready : 랜더링 다 끝나면 실행
                 $('#click_me').bind('click', clickHandler);
                 $('#remove_event').bind('click', function(e){ // 익명함수
                     $('#click_me').unbind('click', clickHandler);
                 });
                 $('#trigger_event').bind('click', function(e){
                     $('#click_me').trigger('click');
                 });
             })
        </script>
    </head>
    <body>
        <input id="click_me" type="button" value="click me" />
        <input id="remove_event" type="button" value="unbind" />
        <input id="trigger_event" type="button" value="trigger" />
    </body>
</html>
이벤트 핸들러
bind, unbind(=die), trigger
bind(이벤트타입, 행동) 으로 이벤트 컨트롤러를 하는 방법
trigger(이벤트타입) : Execute all handlers and behaviors attached to the matched elements for the given event type.
unbind : 이벤트 제거
이벤트 헬퍼 : 좀더 간결하고 편하다.
<html>
    <head>
        <script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.6.2/jquery.min.js"></script>
        <script type="text/javascript">
            function clickHandler(e){
                alert('thank you');
            }
            $(document).ready(function(){
                 $('#click_me').click(clickHandler);
                 $('#remove_event').click(function(e){
                     $('#click_me').unbind('click', clickHandler);
                 });
                 $('#trigger_event').click(function(e){
                     $('#click_me').trigger('click');
                 });
             })
        </script>
    </head>
    <body>
        <input id="click_me" type="button" value="click me" />
        <input id="remove_event" type="button" value="unbind" />
        <input id="trigger_event" type="button" value="trigger" />
    </body>
</html>
Element Control
자식으로 삽입 ( 태그 아래 )
.append(), .appendTo(), .html(), .prepend(), .prependTo(), .text()
형제로 삽입 ( <b> 태그 )
.after(), .before(), .insertAfter(), .insertBefore()
부모로 감싸기
.unwrap(), .wrap(), .wrapAll(), .wrapInner()
<script>$("span").wrap("<div><div><p><em><b></b></em></p></div></div>");</script>
삭제
.detach(), .empty(), .remove(), .unwrap()
치환
.replaceAll(), .replaceWith()
클래스
.addClass(), .hasClass(), .removeClass(), .toggleClass()
속성 제어
.attr(), .prop(), .removeAttr(), .removeProp(), .val()
FORM
<!DOCTYPE html>
<html>
    <head>
        <style>
            span {
            }
        </style>
        <script src="http://code.jquery.com/jquery-latest.js"></script>
    </head>
    <body>
        <p>
            <input type="text" />
            <span></span>
        </p>
        <script>
            $("input").focus( function () {
                $(this).next("span").html('focus');
            }).blur( function() {
                $(this).next("span").html('blur');
            }).change(function(e){
                alert('change!! '+$(e.target).val());
            }).select(function(){
                $(this).next('span').html('select');
            });
        </script>
    </body>
</html>
탐색

<tr id="add"><td><div class="title">.add(selector)</div>엘리먼트를 추가한다</td></tr>
<tr id="andSelf"><td><div class="title">.andSelf()</div>현재 엘리먼트 셋에 이전 엘리먼트 셋을 더 한다</td></tr>
<tr id="children"><td><div class="title">.children([selector])</div>자식 엘리먼트를 선택한다</td></tr>
<tr id="closet"><td><div class="title">.closest(selector)</div>가장 가까운 selector 조상 엘리먼트를 탐색한다</td></tr>
<tr id="each"><td><div class="title">.each(function(index,Element))</div>현재 엘리먼트 셋에 반복 작업을 실행한다</td></tr>
<tr id="end"><td><div class="title">.end()</div>이전 체인 컨텍스트로 돌아간다.</td></tr>
<tr id="eq"><td><div class="title">.eq(index)</div>현재 엘리먼트 셋에서 index에 해당하는 엘리먼트를 선택한다</td></tr>
<tr id="filter"><td><div class="title">.filter(selector)</div>현재 엘리먼트 셋에서 selector에 해당하는 엘리먼트를 선택한다</td></tr>
<tr id="find"><td><div class="title">.find(selector)</div>현재 엘리먼트 셋에서 selector에 해당하는 자손 엘리먼트를 선택한다</td></tr>
<tr id="first"><td><div class="title">.first()</div>현재 엘리먼트 셋 중 첫번째 엘리먼트를 선택한다</td></tr>
<tr id="last"><td><div class="title">.last()</div>현재 엘리먼트 셋 중 마지막 엘리먼트를 선택한다</td></tr>
<tr id="next"><td><div class="title">.next()</div>각각의 엘리먼트에 대한 다음 형재 엘리먼트를 선택한다</td></tr>
<tr id="nextAll"><td><div class="title">.nextAll()</div>각각의 엘리먼트에 대한 다음 형재 엘리먼트 전부를 선택한다</td></tr>
<tr id="prev"><td><div class="title">.prev()</div>각각의 엘리먼트에 대한 이전 형재 엘리먼트를 선택한다</td></tr>
<tr id="prevAll"><td><div class="title">.prevAll()</div>각각의 엘리먼트에 대한 이전 형재 엘리먼트 전부를 선택한다</td></tr>
<tr id="siblings"><td><div class="title">.siblings()</div>각각의 엘리먼트에 대한 형재 엘리먼트 전부를 선택한다</td></tr>
<tr id="slice"><td><div class="title">.slice(start, [end])</div>현제의 엘리먼트 셋 중 start에서 end까지의 엘리먼트를 선택한다</td></tr>
]]></description>
        </item>
        <item>
            <title><![CDATA[JavaScript]]></title>
            <link>https://velog.io/@be-quieth/JavaScript</link>
            <guid>https://velog.io/@be-quieth/JavaScript</guid>
            <pubDate>Sun, 22 Jan 2023 11:39:44 GMT</pubDate>
            <description><![CDATA[<h1 id="javascript">JavaScript</h1>
<p>브라우저에서 HTML, CSS를 <strong>동적</strong>으로 제어하기 위해 만들어진 언어</p>
<p>Node.js : 서버측에서 실행되는 JS</p>
<p>UI : User Interface</p>
<p>API : Application Programing Interface</p>
<p>코드의 형태를 띄고 있는 인터페이스. ex) alert Interface</p>
<p>복잡한 코드를 띄고 있음에도 불구하고 API를 통해 보다 간단한 개발이 가능하도록 해주는 인터페이스.</p>
<p>Document → DOM (Document Object Model) → Window 순으로 서칭 범위를 넓혀가며 필요한 기능 찾기</p>
<p><a href="https://nodejs.org/api/">Index | Node.js v19.4.0 Documentation</a></p>
<hr>
<h1 id="언어---js">언어 - JS</h1>
<ul>
<li><p>typeof : 데이터형을 알려주는 기능 (like var_dump)</p>
<pre><code class="language-jsx">  alert(typeof &quot;1&quot;);</code></pre>
</li>
<li><p>일치연산자</p>
<pre><code class="language-jsx">  alert(1==&#39;1&#39;); // true
  alert(1===&#39;1&#39;); // false
  // ===같은 경우 값과 데이터형이 모두 정확히 일치해야 true를 반환한다.
  -------------------------------
  alert(0 === -0); // true
  alert(NaN === NaN); // false
  -------------------------------
  alert(1!=1); // false
  alert(1!==1); // false</code></pre>
</li>
<li><p>0 : false / 나머지 : true</p>
</li>
<li><p>변수 선언시 var로 한다. &amp; for와 while문 형식은 java와 동일</p>
<pre><code class="language-jsx">  var i = 1;

  for(var i = 0; i &lt; 10; i++) {
      alert(i);
  }

  while(i &lt; 10) {
      alert(i);
  i++;
  }</code></pre>
</li>
</ul>
<h2 id="함수-선언1-2--익명함수">함수 선언1, 2 &amp; 익명함수</h2>
<pre><code class="language-jsx">// 함수 선언 방법 1
function numbering(start) {
    while(start &lt; 10) {
        console.log(start);
        start++;
    }
    return &#39;successful&#39;;
}

// 함수 선언 방법 2
numbering = function() {
    while(start &lt; 10) {
        console.log(start);
        start++;
    }
    return &#39;successful&#39;;
}

// 정의와 호출을 같이 하는 방식...이름이 필요 X -&gt; 익명함수
// 1회성으로 작성할 때 사용하는 테크닉
(function() {
    while(start &lt; 10) {
        console.log(start);
        start++;
    }
    return &#39;successful&#39;;
})();</code></pre>
<h2 id="배열">배열</h2>
<ul>
<li>대괄호([])는 배열을 만드는 기호이다.</li>
</ul>
<pre><code class="language-jsx">var id = [&#39;1&#39;, &#39;2&#39;, &#39;3&#39;]

alert(id[0]);
alert(id[1]);
alert(id[2]);
---------------------------
// 배열에 원소 추가하기
id.push(&#39;4&#39;); // 끝에 4 추가
id.concat([&#39;5&#39;, &#39;6&#39;]); // 끝에 5, 6 추가
id.unshift(&#39;0&#39;); // 배열의 처음에 0 추가, 기존 값들의 색인(index)은 1씩 증가(shift)
id.splice(2,0,&#39;1.5&#39;); // 2번째 인덱스에 0개를 삭제한 후 1.5를 끼워넣는다.
---------------------------
id.pop(); // 맨 끝 원소 삭제
---------------------------
id.sort(); // 오름차순 정렬
id.reverse(); // 내림차순 정렬</code></pre>
<h2 id="객체object">객체(Object)</h2>
<ul>
<li>연관배열 or 맵 or 딕셔너리와 같다.</li>
</ul>
<pre><code class="language-jsx">// 객체 선언 방법1
var grades = {&#39;a&#39; : 88, &#39;b&#39; : 89, &#39;c&#39; : 90};

// 객체 선언 방법2
var grades = {};
grades[&#39;a&#39;] = 88;
grades[&#39;b&#39;] = 89;
grades[&#39;c&#39;] = 90;

//객체 선언 방법3
var grades = new Object();
grades[&#39;a&#39;] = 88;
grades[&#39;b&#39;] = 89;
grades[&#39;c&#39;] = 90;

//객체 호출방법
alert(grades.a); // 88
alert(grades[&#39;a&#39;]); // 88</code></pre>
<ul>
<li>객체는 객체를, 함수를 담을 수도 있다.</li>
</ul>
<pre><code class="language-jsx">var grades = {
    &#39;list&#39; : {&#39;a&#39; : 100, &#39;b&#39; : 90, &#39;c&#39; : 80}
    &#39;show&#39; : function() {
        alert(&#39;Hello world&#39;);
    }
    &#39;this&#39; : function() {
        alert(this); // this : 이 함수가 속해있는 객체를 가리키는 변수
    }
}

alert(grades[&#39;list&#39;][&#39;a&#39;]); // 100
**alert(grades[&#39;show&#39;]); // function() { ~~ }
alert(grades[&#39;show&#39;]()); // Hello world**

var grades = {
    &#39;list&#39; : {&#39;a&#39; : 100, &#39;b&#39; : 90, &#39;c&#39; : 80}
    &#39;show&#39; : function() {
        for(var level in this.list) {
            console.log(level, this.list[level]);
        }
    }
}</code></pre>
<h2 id="모듈">모듈</h2>
<pre><code class="language-jsx">&lt;script src=&quot;greeting.js&quot;&gt; &lt;/script&gt;</code></pre>
<p>js파일을 따로 빼서 만듦으로서 유지보수에 적합하게 만든다. (모듈화)</p>
<ul>
<li><p>모듈 → 라이브러리 (ex) JQuery</p>
<pre><code class="language-jsx">  &lt;script src=&quot;https://code.jquery.com/jquery-1.11.0.min.js&quot;&gt;&lt;/script&gt;</code></pre>
</li>
</ul>
<h2 id="정규표현식">정규표현식</h2>
<ol>
<li>컴파일<ol>
<li>패턴(대상)을 찾는다.</li>
</ol>
</li>
<li>실행<ol>
<li>추출 (exec), Test(test), 치환(replace) 등의 작업을 실행한다.</li>
</ol>
</li>
</ol>
<ul>
<li><p>자바스크립트에서의 정규표현식</p>
<pre><code class="language-jsx">  // 정규표현식 표현방법 1
  var pattern = /a/; // / 사이의 패턴을 찾는다.

  // 방법 2
  var pattern = new RegExp(&#39;a&#39;); // Regular Expression(a)를 찾는 객체를 하나 만듦.</code></pre>
<pre><code class="language-jsx">  pattern.exec(&#39;abcde&#39;); // [&#39;a&#39;] // abcde 중에 a를 찾는 것. 없으면 null을 리턴.
  pattern.test(&#39;abcde&#39;); // true - a 존재함
  pattern.test(&#39;bcde&#39;); // false - a 존재하지 않음
  var str = &#39;abcdef&#39;;
  str.replace(pattern, &#39;A&#39;); // &#39;Abcdef&#39;

  var oi = /a/i; // i 는 대소문자 구분을 하지 않고 찾는다.
  var xg = /a/;
  &quot;abcdea&quot;.match(xg); // [&#39;a&#39;]
  var og = /a/g; // g 는 중복을 허용한다.
  &quot;abcdea&quot;.match(og); // [&#39;a&#39;, &#39;a&#39;]
  var ig = /a/ig;
  &quot;AbcdeAa&quot;.match(ig); // [&#39;A&#39;, &#39;A&#39;, &#39;a&#39;]</code></pre>
</li>
<li><p>캡쳐</p>
<pre><code class="language-jsx">  (\w+)\s(\w+) ... 하나 이상의 문자(a-Z,0-9)그룹 후 공백 후 하나~
  ex) A B | 0 r | 등등

  var pattern = /(\w+)\s(\w+)/; // $1 : coding, $2 : everybody
  var str = &quot;coding everybody&quot;;
  var result = str.replace(pattern, &quot;$2, $1&quot;); // everybody, coding

  즉, 그룹을 지정하고 그 그룹을 가져와 사용한다 : 캡쳐</code></pre>
</li>
</ul>
<h2 id="함수지향">함수지향</h2>
<pre><code class="language-jsx">var vscope = &#39;global&#39;;
function fscope() {
    var vscope = &#39;local&#39;;
    alert(vscope);
}
fscope(); // local
alert(vscope); // global

function fscope() {
    vscope = &#39;local&#39;;
    alert(vscope);
}
fscope(); // local
alert(vscope); // local</code></pre>
<p>var를 사용하지 않고 선언하면 global 선언이 되므로 값이 변경된다.</p>
<p>var선언을 습관화하자. for 코드의 재사용성</p>
<h2 id="유효범위의-대상">유효범위의 대상</h2>
<p>JS는 함수에 대해서만 유효 범위를 제한한다. for 문이나 기타 {} 안의 변수들은 다른 언어들과 달리 함수의 {}만 아니면 사용 가능하다는 것이다.</p>
<ul>
<li>정적(Lexical) 유효범위</li>
</ul>
<pre><code class="language-jsx">var i = 5;

function a() {
    var i = 10;
    b();
}

function b() {
    alert(i);
}

a(); // 5</code></pre>
<h2 id="비동기-처리">비동기 처리</h2>
<p>Ajax - Asynchronous Javascript And XML</p>
<p>리로딩을 하지 않고 서버와 웹 브라우저가 내부적으로 소통하는 기술</p>
<pre><code class="language-jsx">&lt;script src=&quot;//code.jquery.com/jquery-1.11.0.min.js&quot;&gt;&lt;/script&gt;
&lt;script type=&quot;text/javascript&quot;&gt;
$.get(
    &#39;http://~~&#39;,
    function(result) { // $.get이 위 url에서 가져온 데이터를 result로 function인자에 넣어줌.
        console.log(result); // 사용자에게 어떤 처리를 위임한다 -&gt; 콜백
    }, &#39;json&#39;
);
&lt;/script&gt;</code></pre>
<h2 id="클로저">클로저</h2>
<p>Closure</p>
<p>내부함수가 외부함수의 맥락에 접근할 수 있는 것을 가리킨다.</p>
<pre><code class="language-jsx">function outter() {
    var title = &#39;coding everybody&#39;;
    return function() {
        alert(title);
    }
}
inner = outter();
inner(); // coding everybody</code></pre>
<pre><code class="language-jsx">function factory_movie(title) {
    return {
        get_title : function() {
            return title;
        },
        set_title : function(_title) {
            title = _title;
        }
    }
}
ghost = factory_movie(&#39;Ghost in the shell&#39;);
matrix = factory_movie(&#39;Matrix&#39;);
alert(ghost); // Ghost in the shell
alert(matrix); // matrix</code></pre>
<pre><code class="language-jsx">var arr = []
  for(var i = 0; i &lt; 5; i++) {
    arr[i] = function(id) {
      return function() {
        return id;
      }
    }(i);
  }
  for (var index in arr) {
    console.log(arr[index]());
  }</code></pre>
<h2 id="arguments">Arguments</h2>
<p>유사 배열 성격을 띈 객체</p>
<ul>
<li>매개변수의 수를 나타내는 2가지 방법<ol>
<li>함수.length : 함수에서 정의된 인자의 수를 나타냄</li>
<li>arguments.length : 함수에 실제로 전달된 인자의 수를 나타냄</li>
</ol>
</li>
</ul>
<h2 id="함수의-호출">함수의 호출</h2>
<ul>
<li><p>Function.apply, Function.call</p>
<ul>
<li><p>function.apply(맥락, 배열) 을 인자로 받는다.</p>
</li>
<li><p>맥락 : 함수가 실행될 맥락을 의미한다.</p>
<pre><code class="language-jsx">  o1 = {val1:1, val2:2, val3:3}
  o2 = {v1:10, v2:50, v3:100, v4:25}
  function sum() {
      var _sum = 0;
      for(name in this) {
          _sum += this[name];
      }
      return _sum;
  }
  alert(sum.apply(o1)); // 6
  alert(sum.apply(o2)); // 185</code></pre>
</li>
</ul>
</li>
</ul>
<h2 id="객체지향">객체지향</h2>
<h3 id="이론">이론</h3>
<ul>
<li>추상화 : 복잡함 속에서 필요한 관점만을 추출하는 행위</li>
<li>부품화가 중요한 것임에는 분명하지만 그 보다 중요한 것은 적절함이다.</li>
<li>연관된 메소드와 그 메소드가 사용하는 변수들을 분류하고 그룹핑하는 것이다.
 바로 그렇게 그룹핑 한 대상이 객체(Object)다.</li>
<li>즉 내부의 동작 방법을 단단한 케이스 안으로 숨기고 사용자에게는 그 부품의 사용방법만을 노출하고 있는 것이다. 이러한 컨셉을 정보의 은닉화(Information Hiding), 또는 캡슐화(Encapsulation)라고 부른다. 자연스럽게 사용자에게는 그 부품을 사용하는 방법이 중요한 것이 된다.</li>
<li>인터페이스는 부품들 간의 약속이다.</li>
</ul>
<h3 id="실재">실재</h3>
<ul>
<li><p>객체 내 변수 : Property (Java에서는 Field)</p>
</li>
<li><p>객체 내 함수 : Method</p>
</li>
<li><p>생성자</p>
<ul>
<li><p>생성자 함수는 일반함수와 구분하기 위해서 첫글자를 대문자로 표시한다.</p>
<pre><code class="language-jsx">function Person(name){
  this.name = name;
  this.introduce = function(){
      return &#39;My name is &#39;+this.name; 
  }
}
var p1 = new Person(&#39;egoing&#39;); // egoing
document.write(p1.introduce()+&quot;&lt;br /&gt;&quot;);

var p2 = new Person(&#39;leezche&#39;);
document.write(p2.introduce()); // leezche</code></pre>
</li>
</ul>
</li>
<li><p>자바스크립트에서 객체를 만드는 주체는 함수다. 함수에 new를 붙이는 것을 통해서 객체를 만들 수 있다.</p>
</li>
<li><p>전역객체</p>
<ul>
<li><p>JS에서 모든 객체는 기본적으로 전역 객체의 property이다. 객체를 명시하지 않으면 암시적으로 window의 프로퍼티로 간주된다. 전역객체의 이름도 호스트환경에 따라서 다른데, 웹브라우저에서 전역객체는 window이지만 node.js에서는 global이다.</p>
<pre><code class="language-jsx">function func(){
  alert(&#39;Hello?&#39;);    
}
func(); // Hello
window.func(); // Hello

var o = {&#39;func&#39;:function(){
  alert(&#39;Hello?&#39;);
}}
o.func(); // Hello?
window.o.func(); // Hello?</code></pre>
</li>
<li><p>결국 함수도 전역 객체의 프로퍼티이기 때문에 여기서 this는 window라는 전역 객체를 가리킨다. Node.js에서는 global</p>
<pre><code class="language-jsx">  function func(){
      if(window === this){
          document.write(&quot;window === this&quot;);
      }
  }
  func();</code></pre>
</li>
</ul>
</li>
<li><p>This</p>
<ul>
<li><p>함수와 this : this는 함수가 소속되어 있는 객체를 가리키며 디폴트는 전역 객체를 가리키게 된다.</p>
</li>
<li><p>메소드와 this : 객체 소속인 method의 this는 그 객체를 가리킨다.</p>
<pre><code class="language-jsx">  var 0 = {
      func : function() {
          if (o === this) {
              document.write(&quot;o === this&quot;);
          }
      }
  }
  o.func();</code></pre>
</li>
<li><p>생성자와 this :  new func(); → 생성자 new를 통해 객체 선언을 해준다.</p>
<pre><code class="language-jsx">  var funcThis = null;
  function Func() {
      funcThis = this;
  }
  var o1 = Func(); // 함수 저장 -&gt; 함수에서 this 호출 -&gt; 전역 객체인 window
  if (funcThis === window) {
      document.write(&#39;window &lt;/br&gt;&#39;);
  }
  var o2 = new Func(); o2 객체 저장 -&gt; 객체에서 메소드 호출 -&gt; this는 o2를 가리킴
  if(funcThis === o2) {
      document.write(&#39;o2 &lt;/br&gt;&#39;);
  }</code></pre>
</li>
<li><p>Apply와 Call</p>
<pre><code class="language-jsx">  function sum(x,y) {return x+y;}
  var sum2 = new Function(&#39;x&#39;, &#39;y&#39;, &#39;return x+y;&#39;);
  sum2(1,2); // 3
  // 함수 Literal을 만들어 준다. (리터럴:보다 편한 문법체계, 객체리터럴, 배열리터럴 등)</code></pre>
<pre><code class="language-jsx">  var o = {}
  var p = {}
   function func() {
      switch(this) {
        case o:
          document.write(&#39;o&lt;br /&gt;&#39;);
          break;
        case p:
          document.write(&#39;p&lt;br /&gt;&#39;);
          break;
        case window:
          document.write(&#39;window&lt;br /&gt;&#39;);
          break;
      }
    }
    func();
    func.apply(o);
    func.apply(p);
  // 즉, 함수는 자바와 달리 객체에 소속되지 않고, window객체, o객체, p객체에 apply된다.</code></pre>
</li>
</ul>
</li>
<li><p>상속 : prototype</p>
<pre><code class="language-jsx">  function Person(name) {
      this.name = name;
    }
    Person.prototype.name = null;
    Person.prototype.introduce = function() {
        return &#39;My name is &#39; + this.name;
    }

    function Programmer(name) {
      this.name = name;
    }
    **Programmer.prototype = new Person();
  // 상속을 위해서는 생성자의 프로토타입에 상속받고자 하는 객체를 생성해주면 된다.
      Programmer.prototype.coding = function() {
          return &quot;hello world&quot;;
      } // 상속된 객체에서 함수를 추가한 케이스. 마찬가지로 prototype 사용.**

      function Designer(name) {
          this.name = name;
      }
      Designer.prototype = new Person();
      Designer.ptototype.design = function() {
          return &quot;beautiful&quot;;
      }

    var p1 = new Programmer(&#39;john&#39;);
    document.write(p1.introduce() + &quot;&lt;br /&gt;&quot;);
      document.write(p1.coding() + &quot;&lt;br /&gt;&quot;);
      var p2 = new Designer(&#39;sarah&#39;);
      document.write(p2.introduce() + &quot;&lt;br /&gt;&quot;);
      document.write(p2.design() + &quot;&lt;br /&gt;&quot;);</code></pre>
</li>
<li><p>Prototype (원형) → 상속 지원을 위한 개념</p>
<ul>
<li>객체 안에 원하는 메소드가 존재하지 않으면, 계속해서 상위 객체로 올라가서 찾는다.</li>
<li>이 기능이 prototype을 통해 가능해진다.<ul>
<li>생성자는 기본적으로 함수이다. 함수 앞에 new를 붙여 생성자가 만들어지며, 이렇게 콜된 값은 객체를 리턴한다.</li>
<li>func.prototype은 객체를 보유하고 있다. 즉, prototype은 객체를 가질 수 있는 funcf라는 객체의 property이다. → Prototype 체인 개념도 나올 수 있음.</li>
</ul>
</li>
</ul>
</li>
</ul>
<h2 id="표준-내장-객체의-확장">표준 내장 객체의 확장</h2>
<p>표준 내장 객체를 상속받아 커스텀 메소드들을 작성함으로서 확장을 이룰 수도 있다.</p>
<h2 id="objectdefault">Object(Default)</h2>
<p>모든 객체는 기본적으로 object를 상속받고 있으며, 따라서 object를 확장할 수도 있다.</p>
<p>hasOwnProperty는 인자로 전달된 속성의 이름이 객체의 속성인지 여부를 확인한다. 만약 prototype으로 상속 받은 객체라면 false를 리턴한다.</p>
<h2 id="데이터타입">데이터타입</h2>
<p>객체와 비객체(Primitive type)로 나눌 수 있다.</p>
<ul>
<li>비객체 ( = Primitive type)<ul>
<li>number</li>
<li>string</li>
<li>boolean</li>
<li>null</li>
<li>undefined</li>
</ul>
</li>
<li>나머지는 객체</li>
<li>비객체임에도 property식 접근이 가능한 이유는 “Wrapper Object” 기능 때문이다.</li>
<li>Wrapper Object<ul>
<li>String, Number, Boolean이 존재한다.</li>
<li>property식 접근이 일어날 때 해당 객체를 만들어 사용한 후 바로 삭제된다.</li>
</ul>
</li>
</ul>
<h2 id="참조">참조</h2>
<ul>
<li>비객체 (이하 primitive type) 들은 복제되지만 객체는 참조된다.</li>
<li>객체는 다른 말로 참조 데이터형이라고도 부른다.</li>
</ul>
<pre><code class="language-jsx">var a = 1;
var b = a;
b = 2;
console.log(a); // 1

var a = {&#39;id&#39;:1}; // 데이터형이 객체이므로 참조형이다. 즉, 값이 바뀌면 같이 바뀐다.
var b = a;
b.id = 2;
console.log(a.id); // 2

var a = 1;
function func(b){
    b = 2;
}
func(a);
console.log(a); // 1

var a = {&#39;id&#39;:1};
function func(b){
    b = {&#39;id&#39;:2}; // b에 새로운 객체를 전달했으므로 a는 상관이 없다.
}
func(a);
console.log(a.id);  // 1

var a = {&#39;id&#39;:1};
function func(b) {
        b.id = 2;
}
func(a);
console.log(a.id); // 2</code></pre>
<h1 id="web---js">WEB - JS</h1>
<ul>
<li><p>이벤트 ( onclick ) 약 10~20개 정도의 이벤트를 정의해 놓았다.</p>
<pre><code class="language-jsx">  &lt;input type=&quot;button&quot; value=&quot;hi&quot; onclick=&quot;alert(&#39;hi&#39;)&quot;&gt;</code></pre>
</li>
<li><p>this</p>
<pre><code class="language-jsx">  &lt;input type=&quot;button&quot; value=&quot;night&quot; onclick=&quot;
    var target = document.querySelector(&#39;body&#39;);
    if(this.value === &#39;night&#39;) {
      target.style.backgroundColor = &#39;black&#39;;
      target.style.color = &#39;white&#39;;
      this.value = &#39;day&#39;;
    } else {
      target.style.backgroundColor = &#39;white&#39;;
      target.style.color = &#39;black&#39;;
      this.value = &#39;night&#39;;
    }
  &quot;&gt;</code></pre>
</li>
<li><p>함수</p>
</li>
</ul>
<p>함수를 콜할 때 this 를 매개변수로 넣으면 이는 함수가 속한 태그를 넘긴다.</p>
<p>만약 매개변수가 없다면 함수 내 this는 전역 객체를 가리키게 된다.</p>
<pre><code class="language-jsx">&lt;input type=&quot;button&quot; value=&quot;night&quot; onclick=&quot;
  nightDayHandler(this);
&quot;&gt;

function nightDayHandler(self) {
      var target = document.querySelector(&#39;body&#39;);
      if(self.value === &#39;night&#39;) {
        target.style.backgroundColor = &#39;black&#39;;
        target.style.color = &#39;white&#39;;
        self.value = &#39;day&#39;;</code></pre>
<ul>
<li>파일 정리</li>
</ul>
<pre><code class="language-jsx">&lt;script src=&quot;colors.js&quot;&gt; // color관련 작업 코드들을 독립 파일로 빼서 만든다.
  &lt;/script&gt;</code></pre>
<h1 id="dom">DOM</h1>
<p><a href="https://m.blog.naver.com/magnking/220972680805">[JavaScript] DOM이란 무엇인가?</a></p>
<p>html을 구성하는 element들을 node 개념으로 바라보고, 더 나아가 객체로 대하는 방식</p>
<p><a href="https://www.notion.so/JQuery-beaf5c60ceb641b6b921d531c55cda43">JQuery</a></p>
<p><a href="https://www.notion.so/AJAX-da4f9c1f81cf4f57bd49e15e52392352">AJAX</a></p>
<p><a href="https://www.notion.so/JSON-70516cebb69e419cb6856c7563599663">JSON</a></p>
]]></description>
        </item>
        <item>
            <title><![CDATA[HTTP]]></title>
            <link>https://velog.io/@be-quieth/HTTP</link>
            <guid>https://velog.io/@be-quieth/HTTP</guid>
            <pubDate>Sun, 22 Jan 2023 11:38:32 GMT</pubDate>
            <description><![CDATA[<p>HTTP
HyperText Transfer Protocol
서버와 클라이언트가 서로 주고받을 수 있는 통신 규약
Request와 Response로 나눠진다.
개발자 도구의 Network 탭 : 웹 서버와 웹 브라우저간의 통신을 모니터링할 수 있는 구역
Request headers
GET(웹브라우저와 웹서버가 어떻게 통신할 것인지) /doc/test.html HTTP/1.1 // Request Line</p>
<hr>
<p>Host: www.~
Accept: ~
Accept-Language: en-us                                 // Request Headers
Accept-Encoding: ~ // 브라우저 데이터가 많아 압축된 경우, 어떤 방식으로 압축했는지 표현
User-Agent: ~ // 웹 브라우저의 다른 말
Content-Length: ~
If-Modified-Since: ~ // 가장 최근 받은 파일을 기록. 웹서버가 응답할 때 자신의 파일과 비교하여 자신이 최근이면 전송. 아니면 전송X
-------------------------------------------- / blank line seperating headers &amp; body</p>
<body> ...
Response headers

<p>HTTP/1.1 200 OK                               //http1.1ver, 200:Success의미, OK:성공!
Date: Sat, 07 Jan 2023 12:41:39 GMT
Server: Apache
Vary: Accept-Encoding
Content-Encoding: gzip                         // gzip으로 압축되어 있다.
X-Content-Type-Options: nosniff
X-Frame-Options: sameorigin
Content-Length: 185                             // 총 컨텐츠 길이: 185 (Byte)
Keep-Alive: timeout=5, max=100
Connection: Keep-Alive
Content-Type: text/html; charset=UTF-8          // html타입, 인코딩 방식:UTF-8</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[PHP ]]></title>
            <link>https://velog.io/@be-quieth/PHP</link>
            <guid>https://velog.io/@be-quieth/PHP</guid>
            <pubDate>Sun, 22 Jan 2023 11:37:57 GMT</pubDate>
            <description><![CDATA[<h1 id="php">PHP</h1>
<p>Personal HomePage
과제용 서버 내 파일 접근시
15.164.95.148(과제 서버 ip)/example2.php(파일 이름)?q=ip-172-31-16-249(내 노트북 ip)
접근자의 ip주소를 url 파라미터로써 요구하는 함수가 존재한다?
데스크톱으로 접근하니 ?q=ip-172-31-16-249(내 노트북 ip)가 없어도 접근 가능하다.
php파일 생성시 ‘touch 파일이름.파일형식’
경로는 /var/www/html
PHP : 웹 서버상에서 쓰는 웹 프로그래밍 언어(PHP, JSP, ASP.NET 등이 있다.)
직관적인 코드 작성 가능, 코드의 양 역시 적음.
텍스트 처리에 특화되어 있어 HTML문저 처리에 적합함.
HTML, CSS, JavaScript를 알아야 함.
Php.ini-production vs php.ini-development
Production : 보안, 퍼포먼스, 실용중심적. Recommended
Development : 에러가 발생하면 해당 에러들을 출력해주기 때문에 개발환경에서만 쓰이는 데 추천함. 보안상 문제가 생길수도 있기 때문
레지스트리?
Visual C++ 2015, apache, php간의 관계?
문법
기본 
PHP는 키워드, 클래스, 함수, 사용자 함수 이름의 대소문자를 구분하지 않는다.
종류
PHP recommanded style
<?php … ?>
HTML 스트립트 스타일</p>
<script language = “php”> … </script>
<p>SGML 스타일
<? … ?>
ASP 스타일
&lt;% … %&gt;
위 3,4번 스타일은 short_open_tag 활성화시 정확히 인식 가능한 듯
서버별 이식성 문제를 피하기 위해 PHP 권장 스타일을 사용하는 것이 좋다.
이중 주석 X
변수 선언시 달러 기호($)를 사용한다.
$변수이름 = 초깃값;
따로 타입을 명시하지 않는다. 해당 변수에 대입하는 값에 따라 자동으로 결정된다.
처음에 어떤 타입의 값을 주었다 해도 다른 타입의 값이 들어갈 때마다 자동으로 타입 변환이 일어난다.
언어 구조(Language construct)
echo()
실제로는 함수가 아니기 때문에 인수를 전달할 때 괄호는 상관 없다.
가변 길이 인수와 같이 함수 문맥으로는 사용 불가
두 개 이상의 인수를 전달할 때는 괄호를 사용하지 못한다.
조건&amp;반복문
조건문
<?php
if(isset($_GET['id'])) {
  echo $_GET['id'];
} else {
  echo "Welcome";
}
?>
반복문
<?php
echo '1<br>';
$i = 0;
while($i < 3) {
  echo '2<br>';
  $i = $i + 1;
}
echo '3<br>';
?>
함수
gettype(<del>) : ~의 타입 리턴
strlen(</del>) : <del>문자열의 길이 리턴
nl2br(</del>) : <del>의 new line을 </br>로 리턴
file_get_contents(</del>) : <del>의 파일의 컨텐츠들을 리턴
echo file_get_contents(&quot;data/&quot;.$_GET[&#39;id&#39;]);
var_dump(</del>) : <del>의 값과 타입을 출력
isset(</del>) : <del>의 값이 set되고 null이 아니면 true.
unset(</del>) : ~의 값을 null로 만듦.
PHP는 컨텐츠를 html로 자동으로 만들어준다.
php : 인터페이스, 함수 같은 느낌
data라는 디렉토리에 정보만 추가해주면 php가 알아서 기존 웹사이트에 추가해준다.
HTML은 정적이지만 PHP는 동적이다.
<?php ~ ?> : html 구문 도중 php 구문이라는 것을 명시한다.
PHP Data Types
Scalar types
싱글값을 hold하고 있는 변수를 의미한다.
bool
true, false 두 값만으로 나뉜다.
false로 인식되는 값들 :
false keyword
(int) 0, -0, (float) 0.0, -0.0
“”, ‘’ (empty string), “0”
array() or [] (empty array)
null
The SimpleXML objects created from attributeless empty elements.
나머지는 true로 인식된다.
int
integer값을 hold하며, php가 실행되는 플랫폼에 따라 표현 가능한 integer가 달라진다.
PHP_INT_SIZE : 특정 플랫폼에서의 표현 가능한 정수의 사이즈를 상수 형태로 나타낸다.
float
floats, doubles, 실수들로 알려져 있다. 
string
큰따옴표나 작은따옴표로 둘러쌓인 characters의 연속
Compound types
Compound data includes the values that contain more than one value.
array
key와 value를 연결한 정렬된 map이다.
array functions 들을 찾아 해결해보자.
indexed array : index로 value들을 연결한 배열
<?php
$coworkers = array('egoing', 'leezche', 'duru', 'taeho');
echo $coworkers[1].'<br>'; // leezche
echo $coworkers[3].'<br>'; // taeho
var_dump(count($coworkers)); // int(4)
array_push($coworkers, 'graphittie');
var_dump($coworkers); // array(5) { [0]=> string(6) "egoing" [1]=> string(7) 
?>                                        // &quot;leezche&quot; [2]=&gt; string(4) &quot;duru&quot; [3]=&gt; string(5) 
                                            // &quot;taeho&quot; [4]=&gt; string(10) &quot;graphittie&quot; }</p>
<p>associative array : string으로 value들을 연결한 배열. []로 묶어 표현한다.
&lt;?php </p>
<p>$prices = [
    &#39;laptop&#39; =&gt; 1000,
    &#39;mouse&#39; =&gt; 50,
    &#39;keyboard&#39; =&gt; 120
];</p>
<p>echo $prices[&#39;laptop&#39;]; // 1000
echo $prices[&#39;mouse&#39;]; // 50
echo $prices[&#39;keyboard&#39;]; // 120
object
OOP 개념의 객체와 같은 존재. properties(필드), behaviors(메소드)와 같은 값들을 가진다.
callable
iterable
Special types
resource
The resource type holds a reference to an external resource, e.g. a filehandle or a database connection.
null
The null type has one value called null that represents a variable with no value.
Else
php문에 수식을 넣으면 계산이 된 값을 웹사이트에서 출력한다.
문자열의 결합 : .(dot) 이라는 concatenation operator를 통해 문자열들을 결합한다.
echo &quot;hello &quot;.&quot;world&quot;; // hello world
문자열의 길이
// int strlen (string $string)</p>
<?php 
$str = 'abcdef';
echo strlen($str); // 6

$str = ' ab cd ';
echo strlen($str); // 7
?>
<p>php 어플리케이션의 입력으로 URL parameter를 사용하는 방법
127.0.0.1/parameter.php?name=egoing&amp;address=서울
? 뒷부분은 url parameter, &amp;는 파라미터간 구분자이다.
<!DOCTYPE html></p>
<html>
  <head>
    <me
ta charset="utf-8">
  </head>
  <body>
    안녕하세요. <?php echo $_GET['address']; ?>에 사시는 <?php echo $_GET['name']; ?>님
  </body>
</html>
$_GET
]]></description>
        </item>
        <item>
            <title><![CDATA[SQL]]></title>
            <link>https://velog.io/@be-quieth/SQL</link>
            <guid>https://velog.io/@be-quieth/SQL</guid>
            <pubDate>Sun, 22 Jan 2023 11:37:19 GMT</pubDate>
            <description><![CDATA[<p>SQL
Structed Query Language
CRUD
Input : Create,Update,Delete
Output : Read
에러로그 확인 : /var/log/mysql
PDO (Php Data Object) : 동일한 코드로 다양한 데이터베이스를 다룰 수 있다.</p>
<p>왜 쿼리 ‘질의’라고 했을까? 예전 프리코스에서 공부할 때 나름 DB역할을 했던 클래스나 다른 각종 기능 단위의 클래스에 대해 ‘객체가 일을 하도록 해라’ 라는 설정과  비슷한 컨셉인 것 같다. 그런데 막상 쿼리를 비롯해서 sql 구조를 잠깐 살펴보니 그런 컨셉은 아니었다. 결국 DB 수정 권한을 부여하는 명령어를 통해 조절하는 것 같다.
Html과 php의 차이 : html은 웹 브라우저에서 소스를 해석하여 보여주지만, php는 서버에서 해석하여 html 코드로 만들어 브라우저에 전달하는 형식이다.
SQL
DB나 파일의 내용 중 원하는 내용을 검색하기 위해 몇 개의 code나 key를 기초로 질의하는 것을 말한다.
데이터베이스용 언어를 SQL(Structed Query Language)라고 한다.
특정DB에서 원하는 조건의 데이터를 조작하는 언어의 집합(문장)을 쿼리라고 한다.
구문은 크게 3개의 범주로 나뉜다.
데이터 정의어(DDL)
데이터베이스를 정의하는 언어이며 데이터의 생성, 수정, 삭제 등 데이터 전체의 골격을 결정하는 역할을 하는 언어이다.
CREATE : 데이터베이스, 테이블 등을 생성하는 역할을 한다.
ALTER : 테이블을 수정하는 역할을 한다.
DROP : 데이터베이스, 테이블을 삭제하는 역할을 한다.
TRUNCATE : 테이블을 초기화시키는 역할을 한다.
데이터 조작어(DML)
‘정의된’ DB에 입력된 레코드를 조회, 수정, 삭제하는 등의 역할을 한다.
SELECT : 데이터 조회
INSERT : 데이터 삽입
UPDATE : 데이터 수정
DELETE : 데이터 삭제
데이터 제어어(DCL)
DB에 접근하거나 객체에 권한을 주는 등의 역할을 하는 언어이다.
GRANT : 특정 DB 사용자에게 특정 작업에 대한 수행 권한 부여한다.
REVOKE : 특정 DB 사용자에게 특정 작업에 대한 수행 권한 박탈, 회수한다.
COMMIT : 저장되지 않은 모든 데이터를 DB에 저장하고, 현재의 트랜잭션을 종료하는 역할을 한다. (트랜잭션 : 쪼갤 수 없는 업무 처리의 최소 단위, 데이터베이스를 변화시키기 위해서 수행하는 작업(select, update, insert, delete 등)의 단위를 뜻한다.)
ROLLBACK : 트랜잭션의 작업을 취소 및 복구하는 역할을 한다.
PHP와 MySQL을 연동하는 API
mysql
mysqli
procedual(함수형)
mysqli_connect(”주소”, “user”, “password”, “database”);
object-oriented(객체지향형)
mysqli::__construct
pdo
테이블 생성
CREATE TABLE author(
    id INT(11) NOT NULL AUTO_INCREMENT,
    name VARCHAR(30) NOT NULL,
    profile VARCHAR(200) NOT NULL,
    PRIMARY KEY(id)
);</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[HTML]]></title>
            <link>https://velog.io/@be-quieth/HTML</link>
            <guid>https://velog.io/@be-quieth/HTML</guid>
            <pubDate>Sun, 22 Jan 2023 11:36:42 GMT</pubDate>
            <description><![CDATA[<h1 id="html">HTML</h1>
<p><strong>HyperText Markup Language</strong></p>
<p><strong>Internet : 도시(운영체제) / Web : 건물(앱.exe)</strong></p>
<p><strong>Web site : 웹페이지들의 그룹</strong></p>
<p><strong>웹사이트를 만들 때는 순서가 중요하다.</strong></p>
<p>Disqus</p>
<p>tawk.to</p>
<ol>
<li>웹-브라우저(Client)</li>
<li>웹-서버(Server)</li>
</ol>
<hr>
<p>2017년 기준 150여개가 넘는 Tag가 존재한다.</p>
<p>태그별 인기도 확인 : html, head, body, title, meta, div, a, script, link, img, span, p, li, ul, style, br 등</p>
<p><a href="https://www.advancedwebranking.com/seo/html-study/">HTML Study | Advanced Web Ranking</a></p>
<ul>
<li><strong>웹 프로그래밍의 핵심은 ‘접근성’이다. 소외되는 사람들이 없도록 html의 의미를 정확히 이해하고 코드를 작성하도록 노력하자.</strong></li>
</ul>
<h1 id="문법">문법</h1>
<h2 id="tag">Tag</h2>
<p>닫지 않는 태그는 볼드로 표시 : 주로 감싸야하는 컨텐츠가 없는 태그가 해당.</p>
<p>중첩해서 사용 가능</p>
<ol>
<li><a href=”~”> </a>: HyperText Reference, 링크<ol>
<li><code>&lt;a href=&quot;https://www.w3.org/TR/html5/&quot; target=&quot;_blank&quot; title=&quot;html5 specification&quot;&gt;</code><ol>
<li>target=”_blank” : 링크 페이지를 새창에서 열게 해주는 속성</li>
<li>title=”~” : 이 링크가 어떤 내용을 담고 있는지를 툴팁으로 보여주는 기능</li>
</ol>
</li>
</ol>
</li>
<li><strong> : 볼드체</li>
<li><u> : underline</li>
<li>&lt;h1~6&gt; : 대제목 2, 3, 4, … 부제2, 부제3, 부제4, …</li>
<li>&lt;br&gt; : 줄바꿈</li>
<li><p> : paragraph, 단락을 설정한다. 단락과 단락의 간격이 고정이어서 간격이 자유로운 br태그를 선호한다.
 1. HTML은 정보를 표현하지만, CSS는 정보를 꾸미는 역할, CSS로 p태그의 간격 한계 극복 가능
 2. CSS : `<**p** style="margin-top:45px;">` - p태그의 위쪽에 45픽셀(px)만큼의 여백(margin) 생성
 3. 따라서 ‘단락의 경계’가 목적인 경우 p태그가 바람직하며, CSS로 간격 조절까지 가능해졌다.</li>
<li><strong><img> :</strong> 이미지 삽입 태그. Tag만으로는 부족한 정보를 보충하기 위해 Attribute라는 문법을 사용한다. 그 중에서 src를 사용한 예시를 본다.<ol>
<li>&lt;img src=”이미지 링크.파일 형식” width=”~%”&gt; 와 같이 표현한다.<ol>
<li>width : 이미지의 크기를 다루는 속성, src : 이미지의 위치 속성</li>
<li>만약 로컬 데이터베이스에 존재하는 이미지를 불러오고자 한다면, src=”디렉토리까지의 경로/이미지파일 이름.해당 파일 형식” 으로 지정한다.</li>
</ol>
</li>
<li>&lt;input ~&gt; : 각각 상황에 맞춰 검색해보자.</li>
</ol>
</li>
<li><iframe> : 동영상 삽입 태그</li>
<li><strong><form> :</strong> 입력된 데이터를 한 번에 서버로 전송한다.<ol>
<li>get : url에 정보가 드러난다. 북마크 방식에 특화<ol>
<li>따라서 받는 쪽에서 $_GET을 사용한다.</li>
</ol>
</li>
<li>post : url에 정보가 드러나지 않아 보안에 장점이 있다.<ol>
<li>따라서 받는 쪽에서 $_POST를 사용한다.</li>
</ol>
</li>
</ol>
</li>
<li><strong><input></strong></li>
<li><strong><hr></strong></li>
<li><strong><meta></strong></li>
</ol>
<h3 id="부모-자식과-목록">부모 자식과 목록</h3>
<ol>
<li><li> : list, 항목을 설정한다.</li>
<li><ul> : unordered list, 정렬되지 않은 형태의 리스트로 설정한다.</li>
<li><ol> : ordered list, 정렬된 형태의 리스트로 설정한다.

</li>
</ol>
<h3 id="본문을-설명하는-태그">본문을 설명하는 태그</h3>
<ol>
<li><title> : 검색엔진이 웹페이지 분석시 가장 중요하게 생각하는 태그이다.</li>
<li><meta> : 페이지를 해석하는 방식에 대해 서술하는 태그이다.</li>
<li><head> : 제목을 나타내는 태그이다.</li>
<li><html> : html 코드 전체를 감싸는 태그이다.</li>
<li><!DOCKTYPE html> : 이 웹페이지가 html로 만들어졌다는 것을 표현하기 위한 태그이다.</li>
</ol>
<h2 id="attribute">Attribute</h2>
<p>Tag만으로 부족한 정보를 제공하기 위해 도입된 문법. 각 태그별 속성들이 존재한다.</p>
<ul>
<li>ex) <img> Tag → src라는 attribute 사용. <img src=”~”></li>
</ul>
<h1 id="이론">이론</h1>
<ul>
<li><p>MarkUp vs MarkDown</p>
<ul>
<li><p>마크업 : 태그 등을 이용하여 문서나 데이터의 구조를 명시하는 언어의 한 가지.</p>
<p>  ex) html</p>
</li>
<li><p>마크다운 : 일반 텍스트 기반의 경량화된 마크업 언어</p>
<p>  ex) wiki, readme file, .md</p>
</li>
</ul>
</li>
<li><p>정보를 요청하는 컴퓨터 : Web browser, Client, 고객</p>
<ul>
<li>ex) 사용자의 컴퓨터에 설치된 프로그램 : Game client</li>
</ul>
</li>
<li><p>정보를 제공하는 컴퓨터 : Web server, Server, 사업자</p>
<ul>
<li>ex) 게임회사의 서버 컴퓨터에 설치된 프로그램 : Game Server</li>
</ul>
</li>
<li><p>Web Server</p>
<ul>
<li>웹 호스팅 : 서버 컴퓨터의 필수 조건들을 갖춘 완성형 서버 컴퓨터를 빌려주는 것.</li>
<li>http : HyperText Transfer Protocol - 웹페이지를 주고받기 위한 통신규약이라는 뜻</li>
<li>Internet Protocol Address : 인터넷 프로토콜 상 주소</li>
<li>5500 : port의 일종, 서버의 종류를 구분하는 역할<ul>
<li>5500 : Web server</li>
<li>6000 : Game server</li>
<li>7000 : Chatting Server</li>
</ul>
</li>
</ul>
</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[2022년 정리10]]></title>
            <link>https://velog.io/@be-quieth/2022%EB%85%84-%EC%A0%95%EB%A6%AC10</link>
            <guid>https://velog.io/@be-quieth/2022%EB%85%84-%EC%A0%95%EB%A6%AC10</guid>
            <pubDate>Sun, 22 Jan 2023 11:33:12 GMT</pubDate>
            <description><![CDATA[<h1 id="git--github">Git &amp; Github</h1>
<ol>
<li>우테코 origin 저장소 → 개인 깃헙 origin 저장소 → 개인 로컬 저장소</li>
<li>개인 로컬 저장소에서 commit을 하며 과제 해결</li>
<li>개인 로컬 저장소 → 개인 깃헙 origin 저장소로 push → 우테코 origin 저장소로 PR 보내기.</li>
</ol>
<p>원래는 PR 후 merge를 하는데 우테코에서는 PR까지만 보내는 듯.</p>
<p>Q. 개인 origin 저장소에서 main으로 merge하는 것도 안되는 것인가?</p>
<p>git push origin [BranchName] : 원격 저장소에 생성 브랜치 push</p>
<p>git push origin —delete [BranchName] : 원격 저장소에 있는 브랜치 delete</p>
<p>git branch -D [BranchName] : 로컬 저장소에 있는 브랜치 delete</p>
<p>Git repository에 local branch 연동하는 법</p>
<ol>
<li>Git repository 생성</li>
<li>git init : 깃 저장소를 초기화, 이 명령어를 입력한 후에야 추가적인 깃 명령어들을 줄 수 있으며, git init은 최초 한번만 시행</li>
<li>git remote add origin [깃헙 주소] : 원격 장소 remote를 생성하고, Github에서 생성한 repository를 연동</li>
<li>git add . : 깃에 파일 전체(.)를 올림</li>
<li>git commit -m “~” : 깃 커밋시 ~와 함께 커밋</li>
<li>git push -u origin main : git에 푸시할때 origin</li>
</ol>
<p><a href="https://www.notion.so/Git-721969216e424fee87f4b00e66f2f450">우형 Git 전략</a></p>
<p><a href="https://www.notion.so/Inflearn-6058f21a35444534b58006748ed65327">Inflearn</a></p>
<p><a href="https://www.notion.so/Git-95a82fc056a14216964d95d3627db429">Git 특강</a></p>
<h1 id="clean-code">Clean Code</h1>
<p>SOLID
<a href="https://blog.itcode.dev/posts/2021/08/15/liskov-subsitution-principle">https://blog.itcode.dev/posts/2021/08/15/liskov-subsitution-principle</a>
SRP : 단일 책임 원칙
클래스는 단 한개의 ‘책임(기능)’을 가져야 한다.
클래스를 변경하는 이유는 단 하나여야 한다.
OCP : 개방-폐쇄 원칙
확장에는 열려있어야 하고, 변경에는 닫혀 있어야 한다.
즉, 기존의 코드를 변경하지 않고 기능을 수정하거나 추가할 수 있도록 설계해야 한다.
자주 변화하는 부분을 추상화 → 기존 코드 수정없이 기능 확장 가능한 유연함 높임.
LSP : 리스코프 치환 원칙 - 어렵다…
상위 타입 객체를 하위 타입 객체로 치환해도 정상적으로 동작해야함.
즉, 상속 관계의 두 클래스간 인풋과 아웃풋이 동일해야 함을 의미.
일반화 관계인 IS-A 관계가 확실해야한다.
아버지 ↔ 아들 X / 포유류 ↔ 동물 O
위 예시를 통해 어느 한 객체가 다른 하나를 완전히 감싸는 구조 필수(확실한 상속)
서브 클래스가 슈퍼 클래스의 기능을 오버라이딩하지 않고 추가적인 필드나 기능만 제공하는 것이다. 부모 클래스의 책임을 변화시키는 기능은 LSP 법칙에 위배되기 때문.
ISP : 인터페이스 분리 원칙
클래스는 자신이 사용하는 메소드에만 의존해야 한다.
한 클래스는 자신이 사용하지 않는 인터페이스는 구현하지 않아야 한다.
여러 세부적인 인터페이스를 구현해서 implement하라.
인터페이스는 해당 인터페이스를 사용하는 클라이언트를 기준으로 잘게 분리되어야 한다.
각 클라이언트가 필요로 하는 인터페이스를 분리함으로써 클라이언트가 사용하지 않는 인터페이스에 변경이 발생하더라도 영향을 받지 않도록 하라.
DIP : 의존 역전 원칙
변하기 쉬운 것(구체적인 것)보다는 변하기 어려운 것(추상적인 것)에 의존해야 한다.
고수준 모듈(인터페이스 등 추상적 개념)은 저수준(구현된 객체)의 구현에 의존하면 안된다.
저수준 모듈이 변경되어도 고수준 모듈은 변경이 필요없는 형태가 이상적이다.
결론
SRP와 ISP는 객체가 커지는 것을 막아준다.
객체가 단일 책임이어야 하고, 클라이언트마다 특화된 인터페이스르 구현하게 함으로써 한 기능의 변경이 다른 곳까지 미치는 영향을 최소화한다.
LSP, DIP, OCP는 서포트를 한다.
OCP는 자주 변화하는 부분을 추상화하고 다형성을 이용함으로써 기능 확장에는 용이하되 기존 코드 변화에는 보수적이도록 한다. 여기서 ‘변화되는 부분을 추상화’하게 도와주는 원칙이 DIP이고, 다형성 구현을 도와주는 원칙이 LSP인 것이다.
MVC 패턴
M : Model (MySQL, IndexedDB 등)
앱이 포함해야 할 데이터가 무엇인지 정의.
V : View (HTML, CSS 등)
앱의 데이터를 보여주는 방식을 정의.
C : Controller (HTML, JavaScript 등)
앱의 사용자로부터의 입력에 대한 응답. 모델 및 뷰를 업데이트하는 로직을 포함.
예시1.
장바구니에 품목 추가or제거 (뷰 → 컨트롤러) → 컨트롤러를 통해 모델 업데이트 (컨트롤러 → 모델) → 업데이트된 모델(데이터)을 뷰로 전송 (모델 → 뷰)
예시2.
데이터 수정없이 뷰만 바꾸고 싶을 때 : 컨트롤러 → 뷰
매우 포괄적이고 넓은 영역의 개념이다. 각 객체의 역할만 이해하면 충분할 듯.
TDD
TDD : 테스트 주도 개발
<a href="https://wooaoe.tistory.com/33">https://wooaoe.tistory.com/33</a>
실패하는 테스트 코드를 ‘먼저’ 작성
해당 테스트 코드를 성공시키기 위한 최소한의 코드 작성
중복 코드 제거, 일반화 등의 리팩토링 수행
→ 요구 사항에 정확히 집중할 수 있다.
→ 이번 과제에 대한 큰 그림을 그리고, 세부 기능 단위로 TDD 실천해보자.</p>
<h1 id="dependency-injection의존-관계-주입">Dependency Injection(의존 관계 주입)</h1>
<p><a href="https://tecoble.techcourse.co.kr/post/2021-04-27-dependency-injection/">의존관계 주입(Dependency Injection) 쉽게 이해하기 (techcourse.co.kr)</a></p>
<p>객체가 의존하는 또 다른 객체를 외부에서 선언하고 이를 주입받아 사용하는 것.</p>
<p>의존관계를 인터페이스로 추상화한다.</p>
<p>그 의존관계를 외부에서 결정하고 주입.</p>
<ol>
<li>클래스 모델이나 코드에는 런타임 시점의 의존관계가 드러나지않는다. 그러기 위해서는 인터페이스만 의존하고 있어야 한다.</li>
<li>런타임 시점의 의존관계는 컨테이너나 팩토리 같은 제 3의 존재가 결정한다.</li>
<li>의존관계는 사용할 오브젝트에 대한 래퍼런스를 외부에서 제공(주입)해줌으로써 만들어진다.</li>
</ol>
<p>장점</p>
<ol>
<li>의존성이 줄어든다</li>
<li>재사용성이 높은 코드가 된다</li>
<li>테스트하기 좋은 코드가 된다</li>
<li>가독성이 높아진다</li>
</ol>
]]></description>
        </item>
        <item>
            <title><![CDATA[2022년 정리9]]></title>
            <link>https://velog.io/@be-quieth/2022%EB%85%84-%EC%A0%95%EB%A6%AC9</link>
            <guid>https://velog.io/@be-quieth/2022%EB%85%84-%EC%A0%95%EB%A6%AC9</guid>
            <pubDate>Sun, 22 Jan 2023 11:30:24 GMT</pubDate>
            <description><![CDATA[<h1 id="소감문">소감문</h1>
<h2 id="오히려-답답한-느낌이었다">오히려 답답한 느낌이었다.</h2>
<p>이번 주차는 지난 주차들과 다르게 클래스들이 분리된 상태로 주어졌다. 처음 기능 구현 목록을 작성할 때는 이 내용들이 확실히 잘 와닿았다. 하지만 막상 구현을 하는 단계로 넘어가니 생각보다 이 클래스들이 많은 제약을 건다는 느낌을 받았다. 그 와중에 처음으로 등장한 인터페이스 클래스가 매우 눈에 띄었다. 기존에 알고 있는 인터페이스는 마치 Lay-out 역할을 하는 것이라고 이론적으로만 알고 있었는데 실제 사용을 하는 것을 보니 신기했다. 그래서 이번 과제에서 인터페이스를 한번 추출해내어 사용해보고 싶었다. 하지만 생각보다 쉽지 않았다. 계속 고민해본 결과 UI를 인터페이스로 해볼까 고민하였지만 output과 input간 공통 특성이 없어서 사용하지 못했고, 결국 일주일은 흘러버렸다.</p>
<h2 id="enum의-활용과-객체를-객체스럽게-하기-위해-노력했다">Enum의 활용과 객체를 객체스럽게 하기 위해 노력했다.</h2>
<p>함수의 길이가 10줄 이내, 예외 상황 최대한 많이, 비즈니스 로직과 UI로직을 나누는 것 등, 다양한 점들을 전부 반영하고자 노력했다. 결과적으로 enum 타입을 사용하니 코드가 눈에 띄게 줄어드는 것을 보았다. 실제로 처음 1차 완성을 했을 때와 다르게 계속 리펙토링을 하면서 enum 상수로 대체하였는데 그 과정에서 함수의 길이 10줄 이내를 전부 이뤄낼 수 있었다.</p>
<p>또한, 데이터베이스라는 것을 도입하였는데, 그동안 생각해온 것들은 데이터베이스는 그야말로 정보의 저장용이니 getter와 setter가 필수라고 생각했었다. 하지만 3주차 피드백을 받고 공부한 결과, 데이터베이스는 최대한 캡슐화해야 하며, 무엇보다 getter, setter가 아닌 그 객체가 직접 일하게 하자는 것을 느꼈고, 이를 최대한 구현해보았다.</p>
<h2 id="테스트-코드는-나름-만족스럽지-못하였다">테스트 코드는 나름 만족스럽지 못하였다.</h2>
<p>처음 기능 구현 목록 단위로 테스트를 구현하다보니 실제 코드들을 커버하는 범위가 아마 부족했을 것이라고 생각했다. 시간이 조금 더 있었다면 테스트를 조금 더 만들어볼 수 있지 않을까 하는 생각이 들었다.</p>
<h1 id="4주간의-과정을-마치며">4주간의 과정을 마치며</h1>
<p>자바의 ‘객체 지향’ 이라는 것에 어느 정도 감이 생겼고, 테스트 코드를 알게 되었으며, 각종 클린 코드를 실천하는 습관을 조금이나마 들일 수 있었다. 본인은 배구를 매우 좋아하는데, 이번 4주 과정을 통해 얻은 실력(?)으로 배구 전략 분석 프로그램을 한번 구현해보고자 한다. 팀별(객체) 데이터를 입력하면 해당 팀에 대한 파훼법을 출력해주는 식으로. 시간이 없어 이만 쓰겠습니다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[2022년 정리8]]></title>
            <link>https://velog.io/@be-quieth/2022%EB%85%84-%EC%A0%95%EB%A6%AC8</link>
            <guid>https://velog.io/@be-quieth/2022%EB%85%84-%EC%A0%95%EB%A6%AC8</guid>
            <pubDate>Sun, 22 Jan 2023 11:29:34 GMT</pubDate>
            <description><![CDATA[<p>기능 구현 목록
InputView
사용자로부터 입력을 받는 역할
패키지 변경 가능
메서드의 시그니처(parameter, name)와 리턴 타입 변경 가능
사용자 값 입력을 위해 필요한 메서드 추가 가능
public int readBridgeSize()
다리의 길이를 입력받는다.
public String readMoving()
사용자가 이동할 칸을 입력받는다.
public String readGameCommand()
사용자가 게임을 다시 시도할지 종료할지 여부를 입력받는다.
OutputView
사용자에게 게임 진행 상황과 결과를 출력하는 역할
패키지 변경 가능
메서드의 이름 변경 불가
parameter나 리턴타입은 필요에 따라 추가하거나 변경 가능
값 출력을 위해 필요한 메서드 추가 가능
public void printMap()
현재까지 이동한 다리의 상태를 정해진 형식에 맞춰 출력한다. 출력을 위해 필요한 메서드의 인자(parameter)는 자유롭게 추가, 변경이 가능하다.
public void printResult()
게임의 최종 결과를 정해진 형식에 맞춰 출력한다. 출력을 위해 필요한 메서드의 인자(parameter)는 자유롭게 추가, 변경이 가능하다.
BridgeGame
다리 건너기 게임을 관리하는 클래스
클래스에 필드(인스턴스 변수) 추가 가능
패키지 변경 가능
메서드의 이름은 변경 불가
parameter와 리턴타입은 필요에 따라 추가하거나 변경 가능
게임 진행을 위해 필요한 메서드를 추가하거나 변경 가능
public void move()
사용자가 칸을 이동할 때 사용하는 메서드. 이동을 위해 필요한 메서드의 반환 타입(return type),인자(parameter)는 자유롭게 추가하거나 변경할 수 있다.
public void retry()
사용자가 게임을 다시 시도할 때 사용하는 메서드. 재시작을 위해 필요한 메서드의 반환 타입(return type),인자(parameter)는 자유롭게 추가하거나 변경할 수 있다.
BridgeMaker
다리의 길이를 입력 받아서 다리를 생성해주는 역할
클래스의 필드(인스턴스 변수) 변경 불가
메서드의 시그니처(parameter, name)와 리턴 타입 변경 불가
public class BridgeMaker {</p>
<pre><code>private final BridgeNumberGenerator bridgeNumberGenerator;

public BridgeMaker(BridgeNumberGenerator bridgeNumberGenerator) {
    this.bridgeNumberGenerator = bridgeNumberGenerator;
}</code></pre><p>/**
     *@paramsize다리의 길이
*@return입력받은 길이에 해당하는 다리 모양.위 칸이면&quot;U&quot;,아래 칸이면&quot;D&quot;로 표현해야 한다.
     */
public List<String> makeBridge(int size) {
        return null;
    }
}
BridgeRandomNumberGenerator
Random값 추출은 bridge.BridgeRandomNumberGenerator의 generate() 사용
이 클래스와 BridgeNumberGenerator 인터페이스의 코드는 변경 불가.
public class BridgeRandomNumberGenerator implements BridgeNumberGenerator {</p>
<pre><code>private static final intRANDOM_LOWER_INCLUSIVE= 0;
private static final intRANDOM_UPPER_INCLUSIVE= 1;

@Override
public int generate() {
    return Randoms.pickNumberInRange(RANDOM_LOWER_INCLUSIVE,RANDOM_UPPER_INCLUSIVE);
}</code></pre><p>}</p>
<h1 id="기능구현목록---1차">기능구현목록 - 1차</h1>
<blockquote>
<h2 id="constants">Constants</h2>
</blockquote>
<h3 id="frontman-from-오징어게임">FrontMan (from 오징어게임)</h3>
<p>게임 중 출력되는 멘트들을 모아놓은 클래스.</p>
<ul>
<li>&quot;다리 건너기 게임을 시작합니다.&quot;</li>
<li>&quot;다리의 길이를 입력해주세요.&quot;</li>
<li>&quot;이동할 칸을 선택해주세요. (위: U, 아래: D)&quot;</li>
<li>&quot;게임을 다시 시도할지 여부를 입력해주세요. (재시도: R, 종료: Q)&quot;</li>
<li>&quot;최종 게임 결과&quot;</li>
<li>&quot;게임 성공 여부: &quot;</li>
<li>&quot;총 시도한 횟수: &quot;</li>
</ul>
<h3 id="errormessages">ErrorMessages</h3>
<p>게임 중 발생하는 예외 상황들에 대한 멘트들을 모아놓은 클래스.<br>
&quot;[ERROR]&quot;로 시작하는 에러 메시지를 출력한다.</p>
<h4 id="illegalargumentexception">IllegalArgumentException</h4>
<ul>
<li>&quot;[ERROR] 다리 길이는 3부터 20 사이의 숫자여야 합니다.&quot;</li>
<li>&quot;[ERROR] 윗칸(U)이나 아랫칸(D)으로만 갈 수 있습니다.&quot;</li>
<li>&quot;[ERROR] 재시도(R) 혹은 종료(Q)중에서 선택해주십시오.&quot;</li>
</ul>
<hr>
<blockquote>
<h2 id="domain-logic">Domain Logic</h2>
</blockquote>
<h3 id="application">Application</h3>
<ul>
<li><input disabled="" type="checkbox"> BridgeGame을 trigger한다.</li>
</ul>
<h3 id="bridgegame">BridgeGame</h3>
<ul>
<li><input disabled="" type="checkbox"> 입력된 다리 길이에 맞춰 BridgeMaker에게 다리를 건설하게 한다.</li>
<li><input disabled="" type="checkbox"> 입력된 값을 따라 U나 D로 이동시킨다.</li>
<li><input disabled="" type="checkbox"> 이동할 칸이 O인지 X인지 판단한다.<ul>
<li><input disabled="" type="checkbox"> 이동할 수 있는 칸이라면 이동한다.</li>
<li><input disabled="" type="checkbox"> 이동할 수 없는 칸이라면 이동 후 실패를 선언한다.<ul>
<li><input disabled="" type="checkbox"> 재시작 여부를 받아 게임을 재시작하거나 종료시킨다.</li>
</ul>
</li>
</ul>
</li>
<li><input disabled="" type="checkbox"> 다리 길이만큼 이동을 했다면 성공을 선언한 후 종료시킨다.</li>
</ul>
<h3 id="bridgemaker">BridgeMaker</h3>
<ul>
<li><input disabled="" type="checkbox"> 0(Lower)과 1(Upper)를 다리 길이만큼 랜덤하게 뽑아 다리를 건설한다.</li>
</ul>
<hr>
<blockquote>
<h2 id="database">Database</h2>
</blockquote>
<h3 id="bridgedata">BridgeData</h3>
<ul>
<li><input disabled="" type="checkbox"> BridgeMaker로 만들어진 다리에 대한 정보를 저장한다.</li>
<li><input disabled="" type="checkbox"> 현재까지 들어온 유저의 입력을 저장한다.</li>
<li><input disabled="" type="checkbox"> 총 시도한 횟수를 저장한다.</li>
</ul>
<hr>
<blockquote>
<h2 id="ui-logic">UI Logic</h2>
</blockquote>
<h3 id="inputview">InputView</h3>
<ul>
<li><input disabled="" type="checkbox"> 다리의 길이를 입력받는다.<ul>
<li><input disabled="" type="checkbox"> &lt;예외 처리&gt; 다리 길이는 3 이상 20 이하의 숫자이다.</li>
</ul>
</li>
<li><input disabled="" type="checkbox"> U, D중 하나의 칸을 입력받는다.<ul>
<li><input disabled="" type="checkbox"> &lt;예외 처리&gt; U나 D만 받을 수 있다.</li>
</ul>
</li>
<li><input disabled="" type="checkbox"> 게임 실패시, 재시작(R)하거나 종료신호(Q)를 입력받는다.<ul>
<li><input disabled="" type="checkbox"> &lt;예외 처리&gt; R이나 Q만 받을 수 있다.</li>
</ul>
</li>
</ul>
<h3 id="outputview">OutputView</h3>
<ul>
<li><input disabled="" type="checkbox"> 게임 시작 문구를 출력한다.</li>
<li><input disabled="" type="checkbox"> 이동할 칸 선택 문구를 출력한다.</li>
<li><input disabled="" type="checkbox"> 현재 칸까지 이동한 다리의 상태를 형식에 맞춰 출력한다.</li>
<li><input disabled="" type="checkbox"> 게임 실패시, 재시도 여부 문구를 출력한다.</li>
<li><input disabled="" type="checkbox"> (1)게임 실패후 종료 혹은 (2)게임 성공시 최종 게임 결과 그림을 출력한다.</li>
<li><input disabled="" type="checkbox"> 최종 게임 성공 여부와 총 시도한 횟수를 출력한다.</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[2022년 정리7]]></title>
            <link>https://velog.io/@be-quieth/2022%EB%85%84-%EC%A0%95%EB%A6%AC7</link>
            <guid>https://velog.io/@be-quieth/2022%EB%85%84-%EC%A0%95%EB%A6%AC7</guid>
            <pubDate>Sun, 22 Jan 2023 11:28:40 GMT</pubDate>
            <description><![CDATA[<h1 id="학습-내용">학습 내용</h1>
<h1 id="before-mission">Before Mission</h1>
<h2 id="객체를-객체스럽게">객체를 객체스럽게</h2>
<p><strong>getter를 사용하는 대신 객체에 메시지를 보내자.</strong></p>
<p><a href="https://tecoble.techcourse.co.kr/post/2020-04-28-ask-instead-of-getter/">https://tecoble.techcourse.co.kr/post/2020-04-28-ask-instead-of-getter/</a></p>
<p>‘자바 빈 설계 규약’에 따르면</p>
<ol>
<li>자바 빈 클래스 설계 시, 클래스의 멤버변수의 접근 제어자는 private 여야 한다.</li>
<li>모든 멤버변수에 대해 get, set 메소드가 존재해야 한다.</li>
<li>get 메소드는 매개변수 x, set 메소드는 하나 이상 존재해야 한다.</li>
</ol>
<p>객체지향 프로그래밍은 객체가 스스로 일을 하도록 하는 프로그래밍이다. getter는 그 객체가 일을 하는게 아니다. 로직을 갖고 있는 형태도 아니고, 커뮤니케이션이 일어나지도 않는다.</p>
<p>→ <em>객체스럽지 못하다</em></p>
<p>&lt;추가 정보&gt; 디미터 법칙 : 객체간의 연결이 길어질수록 불안정해진다. (train werck)</p>
<ol>
<li>상태를 가지는 객체를 추가했다면 객체가 제대로 된 역할을 하도록 구현해야 한다.</li>
<li>객체가 로직을 구현하도록 해야한다.</li>
<li>객체에 메시지를 보내 일을 하도록 하자.</li>
</ol>
<p>Collection 인터페이스를 사용하는 경우 외부에서 getter 메서드로 얻은 값을 통해 상태값을 변경할 수 있다.</p>
<p>→ Collections.unmodifiableList()와 같은 Unmodifiable Collection을 사용해 외부에서 변경하지 못하도록 하는 것이 좋다.</p>
<h2 id="테스트하기-어려운-코드-공략">테스트하기 어려운 코드 공략</h2>
<p><a href="https://tecoble.techcourse.co.kr/post/2020-05-07-appropriate_method_for_test_by_parameter/">https://tecoble.techcourse.co.kr/post/2020-05-07-appropriate_method_for_test_by_parameter/</a></p>
<h2 id="도메인-모델링">도메인 모델링</h2>
<p><a href="https://incheol-jung.gitbook.io/docs/study/ddd-start/1">1장 도메인 모델 시작 - Incheol&#39;s TECH BLOG (gitbook.io)</a></p>
<h2 id="stream-api">Stream API</h2>
<p>map, trim, max, compareTo, get  </p>
<h2 id="클래스를-final-화-신기하다">클래스를 final 화.. 신기하다.</h2>
<h2 id="패키지-변경시-커밋-내용-chore">패키지 변경시 커밋 내용? Chore.</h2>
<h1 id="during-mission">During Mission</h1>
<h2 id="nested-test">Nested Test</h2>
<p><a href="https://giantdwarf.tistory.com/56">junit5 @Nested 계층구조로 테스트코드 작성하기 (tistory.com)</a></p>
<h2 id="정규식">정규식</h2>
<p><a href="https://hbase.tistory.com/160">[Java] 정규표현식 사용법 및 예제 - Pattern, Matcher (tistory.com)</a></p>
<h2 id="test-case중-null값을-넣으면-예외-처리가-이루어지지-않는다">Test Case중 Null값(””)을 넣으면 예외 처리가 이루어지지 않는다.</h2>
<p>알고보니 Null 값은 ==로 하면 안되고, Objects.equals 로 해주어야 한다!!</p>
<h2 id="예외-처리한-부분부터-다시-시작">예외 처리한 부분부터 다시 시작…?</h2>
<p>attempt나 예외 처리부분 재시작 기능은 어떻게 구현하지?</p>
<h2 id="랜덤-생성-부분에-대한-테스트는-어떻게">랜덤 생성 부분에 대한 테스트는 어떻게?</h2>
<p>bridgeNumberGenerator 부분 테스트는 어떻게 해야할까? 나중에 리펙토링해보자.</p>
<p><a href="https://www.slipp.net/questions/557">https://www.slipp.net/questions/557</a></p>
<h2 id="iostream">IOSTREAM</h2>
<p><a href="https://velog.io/@qlgks1/%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4-%EC%9E%90%EB%B0%94-%EC%A4%91%EA%B8%89-IO">[프로그래머스] 자바 중급 - IO / stream, reader, writer (velog.io)</a><del>텍스트</del></p>
]]></description>
        </item>
        <item>
            <title><![CDATA[2022년 정리6]]></title>
            <link>https://velog.io/@be-quieth/2022%EB%85%84-%EC%A0%95%EB%A6%AC6</link>
            <guid>https://velog.io/@be-quieth/2022%EB%85%84-%EC%A0%95%EB%A6%AC6</guid>
            <pubDate>Sun, 22 Jan 2023 11:26:17 GMT</pubDate>
            <description><![CDATA[<p>기능 구현 목록
Model : 데이터 관리
ConstantDataStorage
1<del>45까지의 수를 포함하는 데이터 저장
당첨 번호의 개수 6 저장
보너스 번호의 개수 1 저장
LottoTicketsStorage
발행된 로또티켓들을 저장
WinNumbersStorage
당첨 번호 저장
BonusNumberStorage
보너스 번호 저장
NumberOfCorrespondedNumberStorage
일치한 번호의 개수 저장
View : Printout, input 관리
MoneyReceiver
금액 입력받음
WinNumberReceiver
당첨번호 입력받음
BonusNumberReceiver
보너스번호 입력받음
ConstantMents
각종 진행중 출력 양식을 상수화한 클래스 구현.
IssuedLottoPrinter
발행한 로또들을 출력.
ResultPrinter
WinResultManager로부터 받은 값을 출력.
Controller : 알고리즘 관리
논리 구현
Casher
1000원 단위로 떨어지는 티켓수 발행. 
남은 금액은 예외처리 후 반환.(예외처리후 프로그램을 종료해야 하는지 알아보자.)
TicketMachine
구입한 금액만큼의 티켓을 랜덤넘버로 발행
WinResultManager
일치하는 번호의 갯수 enum으로 반환
EarningRateCalculator
수익률 계산.
예외 처리 (To User : <U> IllegalArgumentException / To pgrogrammer : <P>)
예외 상황시 반드시 앞에 [ERROR] 출력(로그 활용)후 에러 문구 같이 출력.
validateLottoNumberRange
로또 번호의 숫자 범위 1</del>45 체크
<U> [ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.
validateDuplicatedNumber
숫자 중복 여부 체크(로또 발행시, 당첨 번호 입력시, 보너스 번호 입력시)
<U> [ERROR] 로또 번호는 중복되지 않아야 합니다.
validateNumberSize
숫자 자릿수 체크(6 or 1(보너스))
Case ‘6’ : <U>  [ERROR] 로또 번호는 총 6개여야 합니다.
Case ‘1’ : <U>  [ERROR] 보너스 번호는 1개여야 합니다.
validateWinnerNumber
당첨자가 5명인지 체크
[ERROR] <P> 당첨자는 총 5명이어야 합니다.
validateIssuedTicketNumber
티켓이 구입한 금액의 1000원 단위에 맞게 나왔는지 체크
[ERROR] <P> 티켓의 갯수가 구입하고자 하는 수량과 다릅니다.
validateMoneyUnit_1000
1000원으로 나눠떨어지는지 확인후 잔돈이 생기는지 체크
[ERROR] <P> 받은 금액에 잔돈이 발생했습니다.
validateUserInputIsMoney
유저가 입력한 값이 숫자인지 확인
[ERRPR] <U> 입력값이 올바르지 않습니다. 숫자를 넣어주세요.
사용자가 잘못된 값을 입력할 경우 IllegalArgumentException을 발생시키고, 에러 메시지는 예외 발생시 로그를 남기는 방식으로 나타낸다. 메시지 출력후 프로그램은 종료된다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[2022년 정리5]]></title>
            <link>https://velog.io/@be-quieth/2022-%EC%A0%95%EB%A6%AC5</link>
            <guid>https://velog.io/@be-quieth/2022-%EC%A0%95%EB%A6%AC5</guid>
            <pubDate>Sun, 22 Jan 2023 11:25:07 GMT</pubDate>
            <description><![CDATA[<h2 id="학습-내용">학습 내용</h2>
<p>Git에서 star를 많이 받은 코드들을 살펴보자.
MVC패턴
예외처리 고찰 (tistory.com)
Model
rule
사용자가 편집하길 원하는 모든 데이터를 가지고 있어야 한다.
뷰나 컨트롤러에 대해 어떠한 정보도 알지 말아야 한다.
변경이 일어나면, 변경 통지에 대한 처리방법을 구현해야 한다.
View
모델이 가지고 있는 정보를 따로 저장해서는 안된다.
모델이나 컨트롤러와 같이 다른 구성요소를 몰라야 한다.
변경이 일어나면 변경 통지에 대한 처리방법을 구현해야 한다.
Controller
모델이나 뷰에 대해서 알고 있어야 한다.
모델이나 뷰의 변경을 모니터링 해야 한다.
비즈니스 로직 / 도메인 로직
비즈니스 로직, 도메인 로직이 도대체 뭐지? (velog.io)
도메인, 비즈니스 : 소프트웨어가 풀고자 하는 현실세상의 문제
‘이 코드가 현실 문제, 즉 비즈니스에 대한 의사결정을 하고 있는가?
도메인 로직은 현실 문제에 대한 의사결정을 하는 코드이다. 나머지 코드는 그 결정을 위한 입력값을 만들어주거나, 그 결정의 결과물을 해석하고 보여주고 전파하는 코드이다.
만약 어떤 코드가 명확하게 도메인 로직인지 아닌지 애매하다면, 해당 코드가 하는 일을 쪼개야 한다는 신호다. 도메인 로직이 분명한 부분과 서비스 로직이 섞여 있을 수도 있다.
소프트웨어 설계의 근본 원칙, 관심사의 분리 (velog.io)
객체 지향도, MVC 패턴도 결국에는 코드를 어떤 단위로 나누고 구조화할지에 대한 고민의 결과물이라는 걸 알았을 때, 되게 흥미로웠다.
글쓰기의 구조는 독자의 관점에서 글이 잘 읽히도록 고민하는 것이고, 소프트웨어의 아키텍처는 다른 프로그래머의 관점에서 코드가 잘 읽히도록 고민하는 것이다.
응집도는 높을수록, 결합도는 낮을수록 좋은 코드이다.
공과 사를 구분해야 일을 잘한다.
공 : 인터페이스 / 사 : 구현 → 캡슐화
A class should have one, and only one, reason to change →변경할 이유를 기준으로 객체를 분리해라.
인터페이스를 별도의 추상 클래스나, 혹은 프로토콜로 정의
하는 것이다. (= 의존성 역전 원칙)
비유하자면 충전기가 USB-C라는 규격만 따르면, 자기가 충전하는 기기가 스마트폰이든 태블릿이든 알바 아니게 되는 상황을 만들 수 있다.
인터페이스의 관심사는 메시지를 보내는 쪽, &#39;클라이언트&#39;다. → 인터페이스에서 관심사를 분리할 때는 클라이언트가 필요한 인터페이스만 쓸 수 있도록 분리하자.
결론 : 도메인 로직에 단위 테스트를 구현해야 한다. 단, UI 로직은 제외한다.
→ 핵심 로직을 구현하는 코드와 UI담당 로직을 분리해서 구현하자.
마크다운 문법
제목 &gt; 부제목 &gt; … : # 붙여가면서 작성. 제목은 # 1개, 부제목은 #2개 등..
#은 총 6개까지 지원한다.</p>
<blockquote>
<p>: Block Quote를 표시한다. </p>
<blockquote>
<p>..할때마다 inner block이 생성됨.
This is a first BQ
hi
hello
순서가 있는 목록은 숫자와 점을 사용하여 표현한다.
어차피 무조건 내림차순으로 정렬된다.
순서가 없는 목록은 *, +, -로 표현한다.
혼합해서 사용도 가능
텝 혹은 4칸 공백을 만나면 변환되기 시작하여 다음 들여쓰기(4칸)가 쓰이지 않은 단어 전까지 변환한다.
시작줄은 윗줄과 한줄 떨어뜨려야 한다. 인식이 잘못될수도 있다.
코드 블럭은 두 가지로 표현 가능하다.</p>
</blockquote>
</blockquote>
<pre><code>{code}</code></pre>
<pre>
<code>
public class BootSpringBootApplication {
  public static void main(String[] args) {
    System.out.println("Hello, Honeymon");
  }

}
</code>
</pre>


<p>public class BootSpringBootApplication {
  public static void main(String[] args) {
    System.out.println(&quot;Hello, Honeymon&quot;);
  }
}
b. “ <code>&quot; 사용
깃헙에서는 코드블럭코드(&quot;</code>&quot;) 시작점에 사용하는 언어를 선언하여 문법강조(Syntax highlighting)이 가능하다.</p>
<pre><code>public class BootSpringBootApplication {
  public static void main(String[] args) {
    System.out.println(&quot;Hello, Honeymon&quot;);
  }
}</code></pre><p>public class BootSpringBootApplication {
  public static void main(String[] args) {
    System.out.println(&quot;Hello, Honeymon&quot;);
  }
}
수평선(페이지 나누기 용도)
“* * <em>”
“**</em>”
“- - -”
링크
참조링크
<a href="URL" title="Optional Title here">link keyword</a></p>
<p>// code
Link: <a href="https://google.com" title="Go google">Google</a></p>
<p>외부링크
사용문법: <a href="link">Title</a>
적용예: <a href="https://google.com," title="google link">Google</a>
자동연결</p>
<ul>
<li>외부링크: <a href="http://example.com/">http://example.com/</a></li>
<li>이메일링크: <a href="mailto:&#97;&#100;&#x64;&#114;&#101;&#x73;&#x73;&#x40;&#x65;&#x78;&#x61;&#x6d;&#x70;&#108;&#101;&#46;&#99;&#111;&#x6d;">&#97;&#100;&#x64;&#114;&#101;&#x73;&#x73;&#x40;&#x65;&#x78;&#x61;&#x6d;&#x70;&#108;&#101;&#46;&#99;&#111;&#x6d;</a>
강조</li>
<li>single asterisks*
<em>single underscores</em></li>
<li><em>double asterisks*</em>
<strong>double underscores</strong>
<del>cancelline</del>
줄바꿈을 위해서는 3칸이상 띄어쓰기를 하면 줄이 바뀐다.
‘java 상수’ 구현 방법
[JAVA] Constant Interface : 상수를 정의한 인터페이스 :: 개발 공부 (tistory.com)
상수에 대해 인터페이스로 사용하는 것은 anti 패턴으로 취급한다.
→ import static 구문 사용을 권장한다.
→ static final 타입이며 대문자 사용.
무언가 상수가 갖는 의미를 표현하고 싶을 때 사용.
public static final int FIRST_ELEMENT_OF_ANSWER = answer[0];
Import &amp; Import static
Static의 사용은 결국 클래스에 대한 인스턴스의 생성없이 메소드를 사용할 수 있다는 것을 말한다.
import static을 사용하면 클래스명 없이 소속 메소드를 사용할 수 있다. 하지만 만약 같은 클래스 내에 동일한 이름의 메소드가 있다면 클래스 자신의 메소드가 우선한다.
클래스 내의 모든 “정적” 메소드를 import 하려면 *를 사용하는데, 권장되는 방식은 아니다.
→ static 메소드만 가져오는 거였구나!
→ import static 하려는 field와 method는 “모두 static으로 정의”되어 있어야 한다.
패키지, 모듈, 라이브러리
패키지 : 클래스들의 모음집. ‘폴더/디렉토리’ 개념. package {패키지, 즉 해당 소스가 속한 폴더 이름}; 식으로 선언한다.
패키지를 통해 라이브러리끼리의 구분이 가능.
하위 패키지를 포함하는 중첩 구조도 가능.
패키지를 사용하는 이유는 클래스명의 고유성을 보장하기 위함.
서로 다른 용도의 라이브러리를 도입할 때 이름이 충돌하는 클래스들이 있을 수 있는데 이럴 때 패키지 기능을 사용하여 클래스의 이름이 충돌하는 것을 방지함.
다른 패키지의 클래스에서 사용될 클래스의 이름 앞에 public을 사용해야 import해서 사용 가능. 다른 패키지의 클래스를 사용할 때 그 클래스의 이름 앞에 package 이름을 붙여 이 클래스가 어느 패키지에 속해있는지를 알려주어야 한다.
접근 제어자에 따른 패키지 적용 가능 범위
멤버 및 생성자
private : 같은 클래스에서만 사용가능
default : 같은 패키지에서만 사용가능
protected : 같은 패키지에 속한 클래스와 다른 패키지에 속한 서브클래스에서만 사용가능
public : 모든 클래스에서 사용 (단, 클래스가 public이 아닌 경우 같은 패키지에서만)
클래스 및 인터페이스
default : 같은 패키지에서만 사용
public : 다른 패키지에서도 사용
라이브러리
공통으로 사용될 수 있는 특정한 기능들을 모듈화한 것.
모듈
외부에서 재사용할 수 있는 패키지들을 묶은 것. 패키지의 상위 개념.
Enum class
<a href="https://techblog.woowahan.com/2527/">https://techblog.woowahan.com/2527/</a>
‘Enum으로 추출한다’라고 표현.
Lombok?
어노테이션을 통해 각종 필수 메소드들을 간단히 만들어주는 기능 모음집.
나중에 적용해보고 싶다. 깔끔한 코드 구현에 도움이 됨.
인풋으로 주어지는 두 값의 연관 관계를 코드로 표현할 수 없기 때문에, 어떤 한 인풋이 다른 인풋에 관련된 기능을 강제할 수 있는 수단이 없다.
입력값을 제한할 수 있다.
같은 타입의 값이면 전부 받아들이는 현상을 방지할 수 있다. 지정된 값만 받을 수 있도록 하는 검증코드가 필요하게 된다.
그룹별 기능을 추가할 때 용이하다.
Enum의 default 생성자는 private로 되어 있으며 public으로 변경하는 경우 컴파일 에러가 발생한다.
Enum 클래스를 구현하는 경우 상수 값과 같이 유일하게 하나의 인스턴스가 생성되어 사용된다. → Singleton 형태로 어플리케이션 전체에서 사용된다.
enum 클래스는 내부적으로 java.lang.enum 클래스를 상속받는다. 따라서 다중 상속이 안되므로 enum은 다른 클래스 상속이 불가능하다.
Enum의 내부 API
Enum의 toString() 메소드는 상수의 이름을 리턴하도록 구현되어 있다.
public enum Rank {
   THREE(3, 4_000) // Enum 인스턴스1, type : 당연히 Rank
   FOUR(4, 10_000) // Enum 인스턴스2
   Five(5, 30_000) // Enum 인스턴스3
   ...
}</li>
</ul>
<p>public static void main(String[] args) {
    System.out.println(Rank.Five.toString());
}
// 결과 : FIVE
values()
Enum 클래스가 가지고 있는 모든 상수 값을 배열의 형태로 리턴. 단순히 String 타입으로 반환하는 것이 아니라 ‘인스턴스’ 형태로 반환한다. 즉, Enum 클래스가 가지고 있는 모든 인스턴스를 배열에 담아 반환하는 것.
Rank[] values = Rank.values();
for(int i = 0; i &lt; values.length; i++) {
    System.out.println(values[i]);
}
// 결과 : THREE, FOUR, FIVE
valueOf()
String을 파라미터로 받으며 입력값(string)과 일치하는 상수 인스턴스가 존재하면 그 ‘인스턴스’를 반환한다.
ordinal()
Enum 클래스 내부에 있는 상수들(인스턴스들)의 Index를 리턴하는 메소드. 0부터 상수의 수 -1 까지 이다.
사용 예시
public enum Winner {
    WINNER(&quot;승리&quot;, Arrays.asList(&quot;kyle&quot;, &quot;pobi&quot;, &quot;hello&quot;, &quot;world&quot;))
    LOSER(&quot;패배&quot;, Arrays.asList(&quot;hodol&quot;, &quot;dunddoung&quot;, &quot;rutgo&quot;))</p>
<pre><code>private final String winner;
private final List&lt;String&gt; list;

Winner(String winner, List&lt;String&gt; list) {
    this.winner = winner;
    this.list = list;
}</code></pre><p>}
상수 선언시 람다식을 활용할 수 있다.
예외
throws는 ‘던진다’는 개념으로 알아서 잘 와닿지 않았는데, ‘뱉어낸다’ 라고 이해하니 잘 와닿았다. 그래서 해당 메소드를 호출한 클래스나 메소드에 예외 처리를 요구하는 것이다. 또한, runtimeException이 아니면 컴파일러가 오류를 잡지 않으므로 그 외 예외를 처리할때는 더욱 신중하게 해야 한다.
함수형 프로그래밍
[프로그래밍] 함수형 프로그래밍(Functional Programming) 이란? - MangKyu&#39;s Diary (tistory.com)
프로그래밍 패러다임
명령형 프로그래밍 : 무엇(What)을 할 것인지 나타내기보다 어떻게(How) 할 건지 설명
절차지향 프로그래밍 : 수행 순서대로 처리
객채지향 프로그래밍 : 객체들의 집합으로 상호작용을 표현
선언형 프로그래밍 : 어떻게(How) 할 건지 나타내기보다 무엇(What)을 할 건지 설명
함수형 프로그래밍 : 순수 함수를 조합하고 소프트웨어를 만드는 방법
명령형과 함수형에서 사용하는 함수는 부수효과의 유무에 따라 차이가 있다.
Stream은 상태를 바꾸는 지역 변수 자체를 없앰으로써 부수효과를 제거하였다.
또한, 함수형 프로그래밍의 관점에 따라 Stream의 파라미터로 함수가 전달될 수 있다.
함수를 변수로 선언하는 것도 가능하며 이 함수를 반환하는 것도 가능하다.
@Test
void customFunction() {
    Function&lt;String, String&gt; function = word -&gt; word.toUpperCase();
    assertThat(function.apply(&quot;text&quot;)).isEqualTo(&quot;TEXT&quot;);
람다식, 함수형 인터페이스
[Java] 람다식(Lambda Expression)과 함수형 인터페이스(Functional Interface) - (2/5) - MangKyu&#39;s Diary (tistory.com)
람다식
: 함수를 하나의 식으로 표현한 것 → 메소드의 이름이 필요 없음 : ‘익명 함수’의 한 종류
익명함수는 모두 일급 객체이다. (일급 객체 : 함수형 프로그래밍 관련 개념)
일급 객체인 함수는 변수처럼 사용 가능, 매개 변수로 전달이 가능하다는 등의 특징이 있다.
람다식으로 선언된 함수는 1급 객체이기 때문에 Stream API의 매개변수로 전달이 가능해진다.
람다식의 특징
람다식 내에서 사용되는 지역변수는 final이 붙지 않아도 상수로 간주된다.
일급 객체의 특성을 갖기 위한 것으로 보임
람다식으로 선언된 변수명은 다른 변수명과 중복될 수 없다.
함수형 인터페이스
: JAVA에서는 객체지향 언어이기 때문에 순수 함수(람다식)와 일반 함수를 다르게 취급한다. 따라서 이를 구분하기 위해 ‘함수형 인터페이스’가 등장했다.
함수형 인터페이스란 함수를 1급 객체처럼 다룰 수 있게 해주는 어노테이션으로, 인터페이스에 선언하여 단 하나의 추상 메소드만을 갖도록 제한하는 역할을 한다.
JAVA의 람다식이 함수형 인터페이스를 반환하기 때문에 이를 사용한다.
@FunctionalInterface
interface MyLambdaFunction {
    int max(int a, int b);
}</p>
<p>public class Lambda {
    public static void main(String[] args) {
        MyLambdaFunction lambdaFunction = (int a, int b) -&gt; a &gt; b ? a : b;
        System.out.println(lambdaFunction.max(3,5));
    }
} // 결과 : 5
Java에서 제공하는 함수형 인터페이스(자주 사용되는 것들을 정의한 4가지 FI)
Supplier<T>
매개변수 없이 반환값만을 갖는다. T get()을 추상 메소드로 갖고 있다.
@FunctionalInterface
public interface Supllier<T> {
    T get();
}</p>
<p>Supplier<String> supplier = () -&gt; &quot;Hello world!&quot;;
System.out.println(supplier.get());
// 결과 : Hello world!
Consumer<T>
객체 T를 전달받으며, 반환값은 없다. void accept(T t)를 추상메소드로 갖는다.
@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
    default Consumer<T> andThen(Consumer&lt;? super T&gt; after) {
        objects.requireNonNull(after);
        return (T t) -&gt; { accept(t); after.accept(t); }
    }
}
Function&lt;T, R&gt; , Predicate<T> 도 있다.
&lt;인터페이스(interface)의 내부 규칙&gt;
아스피린 개발자 :: [Java] 인터페이스 (interface)의 기본 문법과 꼭 지켜야 하는 규칙 (tistory.com)
인터페이스는 호출 규칙을 정의하는 것이기 때문에 추상 메서드만 선언 가능하다.
인터페이스는 인스턴스 변수를 가질 수 없다.
즉 인터페이스에 선언된 모든 메서드는 public이고 abstract이다. 또한 인터페이스에 선언된 모든 필드(영역)는 public이고 static이며 final이다.
Stream.API
[Java] Stream API에 대한 이해 - (1/5) - MangKyu&#39;s Diary (tistory.com)
[Java] Stream API의 활용 및 사용법 - 기초 (3/5) - MangKyu&#39;s Diary (tistory.com)
[Java] Stream API의 고급 활용 및 사용 시의 주의할 점 - (4/5) - MangKyu&#39;s Diary (tistory.com)
데이터를 추상화하고, 처리하는데 자주 사용되는 함수들을 정의해두었다. 데이터의 추상화덕에 데이터 종류에 상관 없이 같은 방식으로 데이터를 처리할 수 있으므로 재사용성이 높다.
특징
원본의 데이터를 변경하지 않는다. 주어진 데이터에 .stream 을 사용함으로서 별도의 stream을 생성하는 것.
따라서 일회용이다. 만약 사용 후 닫힌 stream에 대해 재사용을 하면 IllegalStateException이 발생하게 된다.
내부 반복으로 작업을 처리한다. 덕분에 간결한 코드의 작성이 가능하다.
nameStream.forEach(System.out::println);
연산 종류
총 3단계로 나눈다.
생성하기
stream 객체 생성 : 배열, 컬렉션, 임의의 수, 파일 등 대부분 stream 생성 가능.
재사용이 불가능하므로 닫히면 다시 생성해야 한다.
Collection 타입 : .stream()
배열 타입 : Stream.of(<del>) or Arrays.stream(</del>)
원시 타입 : {Type}Stream / ex) IntStream, DoubleStream 등
가공하기
연산 결과를 다시 stream으로 반환하기 때문에 메소드체이닝이 가능하다.
Filter (정제)
조건에 맞는 데이터만을 정제하여 더 작은 컬렉션을 만들어내는 연산. 인자로 함수형 인터페이스 Predicate를 받고 있기 때문에 boolean을 반환하는 람다식을 작성하여 filter 함수를 구현할 수 있다.
Stream<String> stream =
    list.stream()
        .filter(name -&gt; name.contains(&quot;a&quot;));
Map (데이터 변환)
기존 Stream 요소들을 변환하여 새로운 Stream을 형성하는 연산. 인자로 함수형 인터페이스 function을 받고 있다. map함수의 람다식은 메소드 참조를 이용해 변경이 가능하다.
Stream<String> stream =
    names.stream()
        .map(s -&gt; s.toUpperCase());
결과만들기
가공된 데이터로부터 원하는 결과를 만들기 위한 최종 연산.
stream의 요소들을 소모하면서 연산이 수행되기 때문에 1번만 처리 가능.
Stream 연산들은 매개변수로 함수형 인터페이스를 받도록 되어있다. 따라서 이와 람다식을 알아야 한다.
Method Reference : 반복되는 작업에 대해 :: 로 표현
TestCode : TDD, BDD
BDD : Dehavior Driven Development
행동 중심 개발을 하면 좋겠다는 생각에서 시작한 스타일
→ 행동을 기반하여 TDD를 수행하자는 공통의 이해.
→ TDD를 수행하려는 어떠한 행동과 기능을 개발자가 더 이해하기 쉽게하는 것이 목적.
따라서 모든 테스트 문장은 Given, When, Then으로 나눠서 작성할 수 있어야 한다.
Given
테스트를 위해 주어진 상태
테스트 대상에게 주어진 조건
테스트가 동작하기 위해 주어진 환경
When
테스트 대상에게 가해진 어떤 상태
테스트 대상에게 주어진 어떠한 조건
테스트 대상의 상태를 변경시키기 위한 환경
Then
앞선 과정의 결과
즉, 어떤 상태에서 출발(Given)하여, 어떤 상태의 변화를 가했을 때(When) 기대하는 어떠한 상태(Then)가 되어야 한다.
public class Calculator{
    public int plus(int a, int b) {
        return a+b;
    }</p>
<p>public class CalculatorTest{
    Calculator calc = new Calculator();</p>
<pre><code>@Test
void plus() {
    // given
    int a = 10;
    int b = 20;

    // when
    int result = calc.plus(a, b);

    // then
    assertEquals(result, a+b);
}</code></pre><p>}
즉, BDD 자체는 TDD를 더 클린하게 사용하기 위한 방법이다.
BDD를 더욱 BDD스럽게 하기 위한 방법은 BDDMockito를 사용하는 것이다.
특정 상황(When)에 대한 가짜 결과를 만들어주는 것을 Stubbing이라고 한다. 즉, 가짜로 수행할 객체를 넣어주는 것이다.
BDDMockito를 이용하면 Mockito의 when()을 given()이라는 메서드로 더 정확한 의미를 전달할 수 있다.
given(someClass.method()).willReturen();</p>
<p>given(memberRepository.existByEmail(any(String.class)).willReturn(false);
Given() 메소드는 어떤 메소드가 실행되었을 때의 테스트를 위한 상황을 설정할 수 있다.
단위 테스트에서 중요한 것은 테스트하려는 대상의 고립이다.
테스트 대상에 연관된 다른 객체들은 관여하지 않도록 우리가 가짜 객체를 넣어줘야 한다.
→ Mockito의 mock()를 이용하였다.
given / willReturn을 @BeforeEach로 실행해서 가짜 객체에 의한 fore-specified answer를 미리 만든다. 그리고 그 값을 JUnit5 테스트 코드로 실행해서 확인하는 것이다.
&lt;틈새 지식&gt;
any() : 모든 값을 받았을 때의 행동 정의.
ex) any(String.class) : 스트링인 모든 객체가 가능하다.
eq() : 특정 값을 받았을 때의 행동 정의
해당 메서드를 수행했을 때 반환하는 값
행동을 반환할 때는 크게 3가지 방법이 존재한다.
willReturn()
특정 메소드가 실행됐을 때, 이에 대한 메소드의 반환을 willReturn에서 정의
will()
invocation(호출)을 통해서 새로운 객체를 반환하거나 아예 새로운 행동 반환 가능
willThrow()
정규식
“(^[0-9]*$)”
^ : 정규식의 시작
$ : 정규식의 끝
[0-9] : 숫자 0~9까지</p>
<ul>
<li>: 0개 이상 있다.</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[2022년 정리4]]></title>
            <link>https://velog.io/@be-quieth/2022%EB%85%84-%EC%A0%95%EB%A6%AC4</link>
            <guid>https://velog.io/@be-quieth/2022%EB%85%84-%EC%A0%95%EB%A6%AC4</guid>
            <pubDate>Sun, 22 Jan 2023 11:24:08 GMT</pubDate>
            <description><![CDATA[<p>기능 구현 목록</p>
<h1 id="1차-기능-구현-목록">1차 기능 구현 목록</h1>
<ol>
<li>시작문구 출력<ol>
<li>“숫자 야구 게임을 시작합니다.”</li>
</ol>
</li>
<li>랜덤 3자리 픽<ol>
<li>데이터 베이스 클래스 구현<ol>
<li>필드<ol>
<li>정답 List</li>
<li>사용자의 인풋 List</li>
<li>Strike 갯수</li>
<li>ball 갯수</li>
<li>낫싱</li>
</ol>
</li>
</ol>
</li>
<li>랜덤 3자리 생성하여 데이터베이스 클래스에 저장.<ol>
<li>GameManager 클래스 생성하여 게임의 처음과 끝 담당.</li>
</ol>
</li>
</ol>
</li>
<li>정답을 Collection API로 받음</li>
<li>입력을 Collection API로 받음</li>
<li>Strike 비교</li>
<li>Ball 비교</li>
<li>낫싱은 S, B가 없을 때</li>
<li>정답이 아닐 경우의 결과 출력</li>
<li>정답일 경우 결과 출력, 1or2 입력 받음</li>
<li>예외 처리</li>
</ol>
<h2 id="1차-최종-결과">1차 최종 결과</h2>
<p><img src="https://s3-us-west-2.amazonaws.com/secure.notion-static.com/5832d2c2-98f1-4716-935c-2e575d976534/1%EC%B0%A8_%EA%B8%B0%EB%8A%A5_%EA%B5%AC%ED%98%84_%EB%AA%A9%EB%A1%9D.png" alt="1차 기능 구현 목록.png"></p>
<p>뭔가 어수선하다. 기능을 분야별로 모으거나 세분화 해보자.</p>
<p>메인에서 만들어지는 객체가 GameManager, Database, Output, CompareNumbers 타입이다.</p>
<ol>
<li><p>SRP 체크</p>
<ol>
<li><p>GameManager</p>
<p> 기능 자체가 너무 큰 것 같다. 세분화 해보자.</p>
<ul>
<li><input checked="" disabled="" type="checkbox"> setAnswer와 userInput은 “setting” 기능이므로 모아서 set class로 따로 구현?</li>
<li><input checked="" disabled="" type="checkbox"> checkInput은 인풋값 예외를 “확인”</li>
<li><input checked="" disabled="" type="checkbox"> isFinish나 isAgain은 게임 실행 과정에서 조건을 “확인”</li>
<li><input checked="" disabled="" type="checkbox"> “확인”만 하는게 아니라 “예외”도 같이 던져주고 있음.</li>
</ul>
</li>
<li><p>Output</p>
<ul>
<li><input checked="" disabled="" type="checkbox"> 조건에 맞춰 출력을 하는데 이는 “확인”후 “출력”이다.</li>
</ul>
</li>
<li><p>CompareNumbers</p>
<ul>
<li><p><input checked="" disabled="" type="checkbox">  숫자 “확인” 후 “저장” → 저장을 할 필요가 있나?</p>
<p>  → checkNumber를 static으로 구현하여 메소드만 사용하도록 하였다.</p>
<p>  → SRP원칙 지킨듯?</p>
</li>
</ul>
</li>
<li><p>Database</p>
<ol>
<li>뭔가 다른 클래스들에 비해 그나마 잘 정리된 클래스같다.</li>
<li>setter와 getter가 많아 클래스가 비대해 보이는데 괜찮은건가?</li>
</ol>
</li>
</ol>
</li>
</ol>
<p>IsAgain에서 userInput 더 좋게 리펙토링 가능?</p>
<p>Exception은 exception끼리</p>
<p>UserInput 입력값이므로 입력은 입력끼리</p>
<p>게임 운영중 나오는 isFinish나 isAgain끼리</p>
<p>GameManager를 게임의 전체적인 진행만 관리하는 클래스로</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[2022년 정리3]]></title>
            <link>https://velog.io/@be-quieth/2022-%EC%A0%95%EB%A6%AC</link>
            <guid>https://velog.io/@be-quieth/2022-%EC%A0%95%EB%A6%AC</guid>
            <pubDate>Sun, 22 Jan 2023 11:20:23 GMT</pubDate>
            <description><![CDATA[<p>onboarding 2주차 학습내용</p>
<h1 id="학습-내용">학습 내용</h1>
<h3 id="인텔리제이-개발-환경-세팅-및-여러-툴-사용해보기-for-개인-스터디">인텔리제이 개발 환경 세팅 및 여러 툴 사용해보기 for 개인 스터디</h3>
<ol>
<li>깃헙에서 개인적인 자바 스터디를 위한 repository를 만들고 소스트리로 클론해서 로컬 저장소로 가져온 다음 project Structure를 세팅했다. 우테코에서 사용한 structure를 최대한 따라갔는데, src → main → java, 그리고 test 등의 파일 경로 등을 세팅해봤다. 처음에 경로들과 파일들을 설정할 때도 그 목적에 맞게 설정해야 한다는 것을 알게 되었다. ex) 모듈, 패키치, 일반 파일, 디렉토리, 등등</li>
<li>인텔리제이 내에서 커밋, 푸쉬해보기<ol>
<li>인텔리제이 툴 자체적으로 commit, push 등의 기능이 있어서 한번 시도해보았다.</li>
<li>결과적으로 소스트리와 같은 역할을 하고 있다는 것을 알게 되었다.</li>
</ol>
</li>
</ol>
<h3 id="git--github"><a href="https://www.notion.so/Git-Github-f5f4ec3334f840298f46bcb88f1fd697">Git &amp; Github</a></h3>
<h3 id="commit-message-conventions"><a href="https://www.notion.so/Commit-Message-Conventions-01a0a7771a564f2c99123ed057d6ef49">Commit Message Conventions</a></h3>
<h3 id="solid--mvc-패턴--tdd"><a href="https://www.notion.so/SOLID-MVC-TDD-a56f9ddd945146cdb2ec0c40b065085f">SOLID &amp; MVC 패턴 &amp; TDD</a></h3>
<h3 id="다형성">다형성</h3>
<ol>
<li><p>객체의 다형성(인터페이스 상속 역시 가능)</p>
<ol>
<li><p>TV는 SmartTV의 부모 객체일 때, TV tv = new SmartTV(); 가 가능하다.</p>
<p> 객체의 다형성이 적용된 결과. 대신 SmartTV에 선언된 메소드들 중 TV에 선언된 메소드와 일치하는 메소드만 호출 가능하며, 메소드는 SmartTV 메소드를 사용한다.</p>
</li>
</ol>
</li>
<li><p>메소드의 다형성</p>
<ol>
<li>메소드가 동일 이름이어도 입력 파라미터가 다르면 개별적인 메소드로 취급(오버로딩?)<ol>
<li>인터페이스로 구현하는 건가? 인터페이스는 오버라이딩을 사용하는데?</li>
</ol>
</li>
</ol>
</li>
</ol>
<h3 id="dependency-injection의존-관계-주입"><a href="https://www.notion.so/Dependency-Injection-4f5a4887df6149d09f9e56eaf3d06410">Dependency Injection(의존 관계 주입)</a></h3>
<h3 id="campnextstepedumissionutils-">Camp.nextstep.edu.missionutils …</h3>
<p><strong>Console Class</strong></p>
<p>Scanner 클래스를 통해 입력을 받는 클래스인듯.</p>
<ol>
<li><p>필드 : private/static/ Scanner scanner</p>
</li>
<li><p>생성자 : default</p>
</li>
<li><p>메소드</p>
<ol>
<li><p>readLine (In : None / Out : String)</p>
<p> 이너 메소드인 getInstance를 통해 scanner를 가져와서 사용자로부터 새로운 입력을 받아 String으로 리턴한다.</p>
</li>
<li><p>getInstance (In : None / Out : Scanner)</p>
<p> scanner가 Null이거나 isClosed가 참이면 새로운 Scanner의 인스턴스를 만들어 반환한다.</p>
</li>
<li><p>isClosed (In : None / Out : Boolean)</p>
<ol>
<li><code>public Field getDeclaredField(String name)</code><ol>
<li><code>Objects.*requireNonNull*(name);</code> : 주어진 문자열이 null이면 NPE, 아니면 그 값을 리턴 - Nullity check</li>
<li><code>public static SecurityManager getSecurityManager()</code> : security manager가 이미 생성됐다면 이를 return. 아니면 Null retrun → sm</li>
<li>if (sm != null) {
 checkMemberAccess(sm, Member.DECLARED, Reflection.getCallerClass(), true);
} : 만약 sm이 존재한다면 </li>
<li><code>throw new NoSuchFieldException(name);</code> : 만약 주어진 field를 몾찾으면 예외 생성.</li>
<li>최종적으로 getDeclaredField는 주어진 String을 검사해서 NullPointerException, NoSuchFieldException, SecurityException을 체크한 후 이 예외에 해당하지 않을 때 field로 리턴한다. 만약 예외 사항에 걸리면 catch되고 isClosed에 true를 리턴.</li>
<li>그 외엔 isClosed에 false가 리턴되어 기존 scanner 사용.</li>
</ol>
</li>
</ol>
</li>
</ol>
</li>
<li><p>Scanner 클래스</p>
<ol>
<li><p>nextLine() : 엔터가 들어오기 전까자의 문자열을 받음</p>
<p> 엔터를 기준으로 종료하기 때문에 이전의 입력에서 엔터가 남아있다면 넘어가버리는 오류가 발생할 수 있다. 주의하자.</p>
</li>
<li><p>next() : 공백이 들어오기 전까지의 문자열을 받음</p>
</li>
</ol>
</li>
</ol>
<p><strong>Randoms Class</strong></p>
<p><code>public static native Thread currentThread()</code> : static 메소드로 호출한 쓰레드의 객체를 반환함.</p>
<p><code>ThreadLocalRandom.*current*()</code> : 멀티쓰레드 환경에서 서로 다른 인스턴스들에 의한 난수를 반환하므로 경합을 하지 않아 동시성에 안전한 방법.</p>
<p>Java는 Seed를 지정하지 않으면 컴퓨터의 현재 시간을 이용하여 난수에 대응한다.</p>
<ol>
<li>필드 : private/static/final Random defaultrandom</li>
<li>생성자 : default </li>
<li>메소드<ol>
<li><code>public static int pickNumberInList(final List&lt;Integer&gt; numbers)</code> : numbers 리스트가 비어있는지 체크한 후 넘버 생성.</li>
</ol>
</li>
</ol>
<h3 id="junit5--assertj"><a href="https://www.notion.so/JUnit5-AssertJ-c3690a89c3514af8b9d0f13c7b3c356a">JUnit5 &amp; AssertJ</a></h3>
<h3 id="java-style-guide"><a href="https://www.notion.so/Java-Style-Guide-444ab1ee5d514d919bc9b927f2c6ac11">Java Style Guide</a></h3>
<h1 id="예외-처리">예외 처리</h1>
<p><a href="https://hbase.tistory.com/157">https://hbase.tistory.com/157</a></p>
<ol>
<li>예외 대한 설명을 최대한 자세히 적어주자.</li>
<li>단, 예외의 이름으로 최대한 설명을 잘 하면 된다.</li>
</ol>
]]></description>
        </item>
    </channel>
</rss>