-------------------------------------------------------템플릿 문자열
var num1 = 1;
var num2 = 2;
var result = 3;
var string1 = num1 + '더하기' + num2 + '는 \\'' + result + '\\'';
console.log(string1);
const num3 = 1;
const num4 = 2;
const result2 = 3;
const string2 = `${num3} 더하기 ${num4}는 '${result2}'`;
console.log(string2);
-------------------------------------------------------객체 리터럴
var sayNode = function(){
console.log('Node');
};
var es = 'ES';
var oldObject = {
sayJS: function(){
console.log('JS');
},
sayNode: sayNode,
};
oldObject[es + 6] = 'Fantastic';
oldObject.sayNode(); // Node
oldObject.sayJS(); // JS
console.log(oldObject.ES6); // Fantastic
const newObject = {
sayJS() {
console.log('JS');
},
sayNode,
[es + 6]: 'Fantastic',
};
newObject.sayNode(); // Node
newObject.sayJS(); // JS
console.log(newObject.ES6); // Fantastic
-------------------------------------------------------화살표 함수
function add1(x, y){
return x + y;
}
const add2 = (x, y) => {
return x + y;
};
const add3 = (x, y) => x + y;
const add4 = (x, y) => (x + y);
function not1(x) {
return !x;
}
const not2 = x => !x;
-------------------------------------------------------
var relationship1 = {
name: 'zero',
friends: ['nero', 'hero', 'xero'],
logFriends: function(){
var that = this; // relationship1을 가리키는 this를 that에 저장
this.friends.forEach(function (friend){
console.log(that.name, friend);
});
},
};
relationship1.logFriends();
const relationship2 = {
name: 'zero',
friends: ['nero', 'hero', 'xero'],
logFriends() {
this.friends.forEach(friend => {
console.log(this.name, friend);
});
},
};
relationship2.logFriends();
-------------------------------------------------------구조분해 할당
var candyMachine = {
status: {
name: 'node',
count: 5,
},
getCandy: function() {
this.status.count--;
return this.status.count;
},
};
var getCandy = candyMachine.getCandy;
var count = candyMachine.status.count;
const candyMachine = {
status: {
name: 'node',
count: 5,
},
getCandy() {
this.status.count--;
return this.status.count;
},
};
const {getCandy, status: {count}} = candyMachine;
-------------------------------------------------------
var array = ['nodejs', {}, 10, true];
var node = array[0];
var obj = array[1];
var bool = array[3];
const array = ['nodejs', {}, 10, true];
const [node, obj, bool] = array;
-------------------------------------------------------클래스
var Human = function(type) {
this.type = type || 'human';
};
Human.isHuman = function(human){
return human instanceof Human;
}
Human.prototype.breathe = function(){
alert('h-a-a-a-m');
};
var Zero = function(type, firstName, lastName){
Human.apply(this, arguments);
this.firstName = firstName;
this.lastName = lastName;
};
Zero.prototype = Object.create(Human.prototype);
Zero.prototype.constructor = Zero; // 상속하는 부분
Zero.prototype.sayName = function() {
alert(this.firstName + ' ' + this.lastName);
};
var oldZero = new Zero('human', 'Zero', 'Cho');
Human.isHuman(oldZero); // true
-------------------------------------------------------
class Human{
constructor(type = 'human'){
this.type = type;
}
static isHuman(human){
return human instanceof Human;
}
breathe(){
alert('h-a-a-a-m');
}
}
class Zero extends Human{
constructor(type, firstName, lastName){
super(type);
this.firstName = firstName;
this.lastName = lastName;
}
sayName(){
super.breathe();
alert(`${this.firstName} $${this.lastName}`);
}
}
const newZero = new Zero('human', 'Zero', 'Cho');
Human.isHuman(newZero); // true
-------------------------------------------------------프로미스
const condition = true; // true면 resolve, false면 reject
const promise = new Promise((resolve, reject) => {
if(condition) {
resolve('성공');
}
else{
reject('실패');
}
});
// 다른 코드가 들어갈 수 있ㅇ므
promise
.then((message) => {
console.log(message); // 성공(resolve)한 경우 실행
})
.catch((error) => {
console.error(error); // 실패(reject)한 경우 실행
})
.finally(() => { // 끝나고 무조건 실행
console.log('무조건');
});
-------------------------------------------------------
promise
.then((message)=> {
return new Promise((resolve, reject) =>{
resolve(message);
});
})
.then((message2) => {
console.log(message2);
return new Promise((resolve, reject) => {
resolve(message2);
});
})
.then((message3) => {
console.log(message3);
})
.catch((error) => {
console.error(error);
});
-------------------------------------------------------
function findAndSaveUser(Users){
Users.findOne({}, (err, user) => { // 첫 번쨰 콜백
if (err) {
return console.error(err);
}
user.name = 'zero';
user.save((err) => { // 두 번째 콜백
if(err) {
return console.error(err);
}
Users.findOne({ gender: 'm' }, (err, user) => { // 세 번째 콜백
//생략
});
});
});
}
-------------------------------------------------------
function findAndSaveUser(Users){
Users.findOne({})
.then((user) => {
user.name = 'zero';
return user.save();
})
then((user) => {
return Users.findOne({ gender : 'm'});
})
.then((user) => {
// 생략
})
.catch(err => {
console.error(err);
});
}
-------------------------------------------------------Promise.all 사용하기
const promise1 = Promise.resolve('성공1');
const promise2 = Promise.resolve('성공2');
Promise.all([promise1, promise2])
.then((result) => {
console.log(result); // ['성공1', '성공2']
})
.catch((error) => {
console.error(error);
});
-------------------------------------------------------async/await 핵심
function findAndSaveUser(Users) {
Users.findOne({})
.then((user) => {
user.name = 'zero';
return user.save();
})
.then((user) => {
return Users.findOne({gender: 'm' });
})
.then((user) => {
// 생략
})
.catch(err => {
console.error(err);
});
}
-------------------------------------------------------
async function findAndSaveUser(User) {
let user = await Users.findOne({});
user.name = 'zero';
user = await user.save();
user = await Users.findOne({gender: 'm'});
// 생략
}
-------------------------------------------------------
async function findAndSaveUser(Users) {
try{
let user = await Users.findOne({});
user.name = 'zero';
user = await user.save();
user = await Users.findOne({gender: 'm'});
//생략
} catch (error) {
console.error(err);
}
}
-------------------------------------------------------async에서의 화살표함수
const findAndSaveUser = async (Users) => {
try {
let user = await Users.findOnce({});
user.name = 'zero';
user = await user.save();
user = await Users.findOne({ gender: 'm'});
// 생략
} catch (error) {
console.error(err);
}
};
-------------------------------------------------------
const promise1 = Promise.resolve('성공1');
const promise2 = Promise.resolve('성공2');
(async () => {
for await (promise of [promise1, promise2]) {
console.log(promise);
}
})();
-------------------------------------------------------
async function findAndSaveUser(Users) {
//생략
findAndSaveUser().then(() => { /* 생략 */ });
//또는
async function other() {
const result = await findAndSaveUser();
}
}
-------------------------------------------------------3. var.js
const odd = '홀수입니다';
const even = '짝수입니다.';
module.exports = {
odd,
even,
};
-------------------------------------------------------3. func.js
const { odd, even} = require('./var');
function checkOddOrEven(num) {
if(num % 2) { // 홀수면
return odd;
}
return even;
}
module.exports = checkOddOrEven;
-------------------------------------------------------3.index.js
const { odd, even } = require('./var');
function checkOddOrEven(num) {
if(num % 2) { // 홀수면
return odd;
}
return even;
}
module.exports = checkOddOrEven;
-------------------------------------------------------타이머
const timeout = setTimeout(() => {
console.log('1.5초 후 실행');
}, 1500);
const interval = setInterval(() => {
console.log('1초마다 실행');
}, 1000);
const timeout2 = setTimeout(() => {
console.log('실행되지 않습니다');
}, 3000);
setTimeout(() => {
clearTimeout(timeout2);
clearInterval(interval);
}, 2500);
const immediate = setImmediate(() => {
console.log('즉시 실행');
});
const immediate2 = setImmediate(() => {
console.log('실행되지 않습니다');
});
clearImmediate(immediate2);
-------------------------------------------------------경로
console.log(__filename);
console.log(__dirname);
-------------------------------------------------------
exports.odd = '홀수입니다.';
exports.even = '짝수입니다.';
-------------------------------------------------------
console.log('require가 가장 위에 오지 않아도 됩니다.');
module.exports = '저를 찾아보세요.';
require('./var');
console.log('require.cache입니다.');
console.log(require.cache);
console.log('require.main입니다.');
console.log(require.main === module);
console.log(require.main.filename);
#pragma once
#include <iostream>
#include <vector>
// [][][][][][][][][][][]
// 0 : Root Node
// Index * 2 : Left =>
// Index * 2 + 1 : Right => 3
// 1
// 2 3
// 4 5 6 7
// 배열로 하면 낭비가 심하다.
// 0
// 2 0
//2 3 4 0
//1 11 1 1 1 0
//1 1 1 111111 0
class Heap
{
public:
Heap() = default;
~Heap() = default;
// 힙의 가장 큰 원소를 반환한다.
const int& top() const;
// 힙이 비었는지 체크한다.
bool empty() const;
// 힙의 크기를 반환한다.
size_t size() const;
// 힙에 값을 삽입한다.
void push(int value);
// 힙에서 값을 제거한다.
void pop();
private:
std::vector<int> _container;
};
#include "Heap.h"
const int& Heap::top() const
{
return _container.front();
}
bool Heap::empty() const
{
return _container.empty();
}
size_t Heap::size() const
{
return _container.size();
}
void Heap::push(int value)
{
// 1. 먼저 맨 끝에 데이터를 삽입한다.
_container.push_back(value);
// 2. 힙의 불변성을 만족할 때까지 데이터를 바꿔준다
// HACK : 첫 번쨰 노드를 1로 생각
size_t currentIndex = size();
while (currentIndex > 1)
{
// 2-1. 부모 노드를 찾는다.
size_t parrentIndex = currentIndex / 2;
// 2-2. 부모 노드와 비교한다.
if (_container[parrentIndex - 1] >= _container[currentIndex - 1])
{
//2-2-1. 부모가 나보다 더 크다면 힙의 불변성을 만족하는 것이므로 종료
break;
}
std::swap(_container[parrentIndex - 1], _container[currentIndex - 1]);
currentIndex = parrentIndex;
}
}
//-------------------------------------------------- 나의 흔적들
/*int size = _container.size();
for (int i = 0; _container.size() != NULL; i++)
{
if (_container[size / 2] < value)
{
std::swap(_container[size / 2], value);
}
else
{
size = size / 2;
}
}*/
//--------------------------------------------------
void Heap::pop()
{
// 1. 마지막 노드를 루트 노드로 가져온다
_container[0] = _container.back();
// 2. 마지막 노드를 제거한다.
_container.pop_back();
// 3. 힙의 불변성을 만족할 때 까지 자식이랑 교체한다.
const size_t currentSize = _container.size(); // 인덱스 유효성 체크를 위해서 사용한다.
size_t currentIndex = 1;
while (true)
{
size_t left = currentIndex * 2;
size_t right = left + 1;
// 3-1. 자식이 존재해야 한다.
if (left > currentSize)
{
break;
}
// 3-2. 왼쪽 자식과 오른쪽 자식 중 더 큰 쪽으로 바꾼다.
size_t child = left;
if (right <= currentSize && _container[left - 1] < _container[right - 1])
{
child = right;
}
// 3-3. 바꿀 자식이 없다면 종료한다.
if (_container[currentIndex - 1] >= _container[child - 1])
{
break;
}
std::swap(_container[currentIndex - 1], _container[child - 1]);
currentIndex = child;
}
}
//-------------------------------------------------- 나의 흔적들..
/*size_t currentIndex = size();
size_t parrentIndex = currentIndex /2;
std::swap(_container.front(), _container.back());
_container.pop_back();
//--------------------------------------------------
while (size() > 2)
{
if (_container[parrentIndex - 1] < _container[parrentIndex * 2 -1])
{
std::swap(currentIndex, parrentIndex);
}
else
{
break;
}
}*/
#include "Heap.h"
int main()
{
Heap heap;
for (int num : {3, 7, 4, 10, 40, 32, 1, 19})
{
heap.push(num);
}
while (false == heap.empty())
{
std::cout << heap.top() << ' ';
heap.pop();
}
}
**Console :**
40, 32, 19, 10, 7, 4, 3, 1
// 오름차순으로 나온다.
→ 여러 컴퓨터가 네트워크 상 연결되어 있는 양태
→ 컴퓨터끼리 어떻게 연결 시킬 것 인가를 말하는 것이다.