반응형
반응형

📝splice

/** (1) remove **/
let arr = [1, 2, 3, 4, 5];
arr.splice(1,2);
console.log(arr); // [1, 4, 5]

/** (2) replace **/
let arr2 = [1, 2, 3, 4, 5];
let result = arr2.splice(1, 3, 100, 200); // 1번째 인덱스에서 3개를 지우고 100, 200을 추가
console.log(arr2);   // [1, 100, 200, 5]
console.log(result); // [2, 3, 4]

/** (3) insert **/
let arr3 = ["나는", "철수", "입니다"];
arr3.splice(1, 0, "대한민국", "소방관"); // 삭제 없이 1번째 인덱스 앞에 추가가 된다
console.log(arr3); // [ '나는', '대한민국', '소방관', '철수', '입니다' ]

splice함수는 배열 삭제, 추가, 업데이트가 가능하고 여러가지 파라미터를 가질 수 있습니다

 

  • (1)과 같이 1번째 인덱스 부터 2개를 삭제할 수 있습니다
  • (2)와 같이 1번째 인덱스로부터 3개를 삭제위치에 데이터를 넣을 수도 있습니다
  • (3)와 같이 따로 삭제는 안 하고 1번째 인덱스 앞에 배열을 추가할 수도 있습니다

 

📝indexOf, lastIndexOf

let arr = [1, 2, 3, 4, 5];
console.log(arr.indexOf(1));        // 0      // 1을 찾는다
console.log(arr.indexOf(3, 2));     // 2      // 2번째 인덱스 부터 3을 찾는다

console.log(arr.indexOf(5, 3));     // 4      // 2번째 인덱스 부터 3을 찾는다
console.log(arr.lastIndexOf(5, 3)); // -1     // 5를 3번째 인덱스부터 앞으로가며 찾는다

indexOf찾고자 하는 요소의 인덱스값을 반환 받을 수 있습니다 만약 없으면 -1을 반환합니다

lastIndexOfindexOf처럼 찾는 요소의 인덱스 값을 찾는데 뒤에서 부터 찾습니다

 

 

 

🔗 참고 및 출처

https://www.youtube.com/watch?v=G360D6lqrfo&list=PLZKTXPmaJk8JZ2NAC538UzhY_UNqMdZB4&index=6 
https://www.youtube.com/watch?v=pJzO6O-aWew&list=PLZKTXPmaJk8JZ2NAC538UzhY_UNqMdZB4&index=7

반응형
반응형

📝toString

let num = 10;
console.log(num.toString());  // "10:
console.log(num.toString(2)); // "1010" (2진수)

let num2 = 255;
console.log(num2.toString(16)); // FF (16진수)

숫자를 문자열로 바꿔주는데 2진수나 16진수로 바로 바꿀수도 있다

 

 

📝indexOf, lastIndexOf

let desc = "Hi guys. Nice to meet you";

console.log(desc.indexOf('to'));      // 14
console.log(desc.indexOf('mam'));     // -1
console.log(desc.lastIndexOf('you')); // 22

if(desc.indexOf('Hi') > -1) {
    console.log("Hi가 포함된 문장입니다")
    // Hi가 포함된 문장입니다
}

찾고자 하는 단어의 위치를 찾을 수 있습니다. 못 찾을 경우 -1을 반환하고 찾으면 해당 인덱스 번호를 반환합니다

 

📝substring

let alphabet = "abcdefghij"

console.log(alphabet.substring(2, 5)); // cde
console.log(alphabet.substring(5, 2)); // cde

substring(${startIndex} , ${endIndex}) 시작 인덱스 ~ 마지막 인덱스까지의 값을 가져옵니다 원래 substr이라는 메소드도 있었지만 @deprecated A legacy feature for browser compatibility로 인해 사용하지 않기로 되었다

 

📝trim

let spaceDesc = "   hello!! ";
console.log(spaceDesc.trim()); // hello!!

좌우 공백을 자릅니다

 

📝repeat

let hello = "Hello!";
console.log(hello.repeat(3)); // Hello!Hello!Hello!

해당 문자열을 반복시킵니다

반응형
반응형

📝parseInt, Number, parseFloat

let margin = '10px';
let redColor = 'f3';
console.log(parseInt(margin)); // 10
console.log(parseInt(margin)); // NaN

console.log(parseInt(redColor));     // NaN
console.log(parseInt(redColor, 16)); // 243
console.log(parseInt('11', 2));      // 3

let padding = '18.5%';
console.log(parseInt(padding));   // 18
console.log(parseFloat(padding)); // 18.5
console.log(Number(padding));     // NaN
  • parseInt문자를 정수형으로 바꾸고 소수점이 있는 경우 버린다.
  • parseFloat의 경우 문자를 실수형으로 바꾼다
  • Number의 경우 문자를 숫자로 바꾼다

parseInt, parseFloat와 Number의 다른점은 뒤에 문자가 있어도 앞에 숫자만 있으면 거기까지만 인식한다 개인적인 생각으로 알아서 처리해서 없애주는 건 내가 원하는 대로 프로그램이 안 굴러갈 수도 있다는 걸 의미하기 때문에 Number를 쓰는게 어떤가 싶다

 

 

📝Math.random

console.log(Math.random()); // 0.2068236122613274 [0 ~ 1 사이 무작위 숫자]

let random = Math.floor(Math.random() * 100) + 1
console.log(random) // 1 ~ 100 랜덤한 숫자

Math.random()만 사용하는 경우 0 ~ 1의 무작위 숫자가 나오는데 정수형으로 바꾸기 위해 Math.random * 100을 통해 사이값의 기준을 정하고 +1을 통해 초기값을 설정한다 이렇게 되어서 초기값이 1이고 사이값이 100이기 때문에 1 ~ 100의 랜덤한 숫자가 나오게 되는 것이다

 

 

📝Math.max, Math.min

console.log(Math.max(1, 4, -4, -10, 54.3)); // 54.3
console.log(Math.min(1, 4, -4, -10, 54.3)); // -10

Math.max를 이용해 최대값Math.min을 이용해 최소값을 구할 수 있다

 

📝Math.abs, Math.pow

console.log(Math.abs(-1)); // 1
console.log(Math.pow(2, 10)); // 1024 = 2^10

 

Math.abs절대값Math.pow를 이용해 제곱근을 구할 수 있습니다

 

🔗 참고 및 출처

https://www.youtube.com/watch?v=ZI6TT93wggA&list=PLZKTXPmaJk8JZ2NAC538UzhY_UNqMdZB4&index=5

반응형
반응형

📝Math.PI, Math.ceil, Math.floor, Math.round, toFixed

// PI
console.log(Math.PI); // 3.141592653589793

// 올림, 내림, 반올림
console.log(Math.ceil(5.1));  // 6
console.log(Math.floor(5.1)); // 5
console.log(Math.round(5.1)); // 5
console.log(Math.round(5.7)); // 6

// 소수 둘째자리까지 표현 + 셋째자리에서 반올림 [예제]
let userRate = 30.1234;
console.log(userRate * 100);                      // Step1) 3012.34
console.log(Math.round(userRate * 100));       // Step2) 3012.34
console.log(Math.round(userRate * 100) / 100); // Step3) 30.12
console.log(userRate.toFixed(2))       // Easy) 30.12

Math.PI파이값을 가져올 수 있고 Math.ceil올림, Math.floor내림, Math.round 반올림이다

소수를 반올림해야하는 경우는 [예제]에 대한 코스를 거쳐야한다 하지만 toFixed라는 함수로 간단하게 사용이 가능하다

 

📝isNaN

// isNaN
let x = Number('x')
console.log(x); // NaN

console.log(x == NaN);    // false
console.log(x === NaN);   // false
console.log(NaN === NaN); // false

console.log(isNaN(Number('x'))); // true [NaN이 맞습니다]

NaN은 신기하게 NaN하고 서로 같지 않다 isNaN을 통해 NaN인지 체크할 수 있다

 

 

 

반응형
반응형

📝XHR

XMLHttpRequest(XHR) 객체는 서버와 상호작용하기 위하여 사용 
즉, 비동기 통신을 위해 필요한 객체

 


📝 Ajax

Asynchronous JavaScript And XML의 약자로 JavaScript를 이용해 비동기 HTTP 통신 라이브러리입니다.
XMLHttpRequest(XHR) 객체를 이용해 필요한 데이터만 불러올 수 있습니다.
jQuery가 있어야 Ajax가 사용한게 아닙니다.
순수 Ajax를 이용해서 구현이 가능한데 너무 복잡하기 때문에 일반적으로 jQuery를 사용합니다.

 

💗장점

jQuery를 통해 쉽게 구현 가능
성공, 실패  등 Event에 따른 Handle 가능


⚠️단점

jQuery를 이용해야 사용이 편하다
Promise 기반이 아니다.

 

let xhr = new XMLHttpRequest();
xhr.onreadystatechange = function() { // 요청에 대한 처리 
  if (xhr.readyState === xhr.DONE) {  // 요청 완료시
    if (xhr.status === 200 || xhr.status === 201) { // 200 또는 201 서버 상태 코드(성공)
      console.log(xhr.responseText);
    } else { // 실패
      console.error(xhr.responseText);
    }
  }
};

xhr.open('GET', 'https://localhost:3000'); // 통신방식, 통신 할 EndPoint
xhr.send(); // xhr 기반으로 요청 
// xhr.abort(); // xhr 기반 요청 취소

XHR 기반으로 통신 (jQuery 사용 X) 

 

 

$.ajax({
    url: https://localhost:3000, // 통신할 EndPoint
    type: 'GET', // 통신 방식
    success: function onData (data) { // 성공 시
        console.log(data);
    },
    error: function onError (error) { // 실패 시
        console.error(error);
    }
});

ajax를 이용한 통신 (jQuery 사용 O)

 


📝 Axios

Node.js와 비동기 통신을 목적으로 만들어진 Promise 기반 HTTP 통신 라이브러리입니다.
return을 Promise로 하기 때문에 비동기를 좀 더 효율적으로 할 수 있습니다.

 

 

💗장점

Promise 기반으로 데이터 다루기가 편리
fetch에는 없는 다양한 처리방법이 존재

 

 

⚠️단점

사용을 위해 모듈 설치 필요 

 

axios({
  method: 'post',
  url: '/get-member',
  data: {
  	id : "monday2"
  }
});

axios 사용 코드

 

 

 


📝 fetch

ES6부터 들어온 JavaScript 내장 라이브러리입니다.
Promise 기반이며 내장 라이브러리라는 장점으로 타 라이브러리를 import할 필요가 없습니다.


💗장점

별도 import가 없기 때문에 time resource등 이점
Promise 기반으로 데이터 다루기가 편리


⚠️단점

지원 하지 않는 웹브라우저 존재 (IE11 등...)
상대적으로 Axios에 비해 빈약한 기능

 

fetch("https://localhost:3000/user/post", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    id: "monday2",
    description: "hello world",
  }),
}).then((response) => console.log(response));
// Response {type: 'basic', url: 'http://localhost:8080/confirmCaptChaColor?userAnswer=13', redirected: false, status: 200, ok: true, …}
// MIME plain/text       → response.text() 사용
// MIME application/json → response.json() 사용

 

 

 

 

 

🔗 참고 및 출처

https://velog.io/@kysung95/%EA%B0%9C%EB%B0%9C%EC%83%81%EC%8B%9D-Ajax%EC%99%80-Axios-%EA%B7%B8%EB%A6%AC%EA%B3%A0-fetch

 

[개발상식] Ajax와 Axios 그리고 fetch

여러분들이 프로젝트를 진행하다보면 클라이언트와 서버 간 데이터를 주고받기 위해 HTTP 통신을 사용하게될겁니다. 주로 어떤것을 사용하시나요? 또, 그것에 대해 얼마나 알고계시나요? 저와

velog.io

https://cocoon1787.tistory.com/756

 

[개발상식] Ajax, axios, fetch 차이점 장단점

🚀 토이 프로젝트를 진행하다 보면 클라이언트와 서버 간의 데이터를 주고받기 위해 비동기 HTTP 통신을 하게 되는데, 이번 포스팅은 이러한 통신을 위해 사람들이 많이 사용하는 Ajax, axios, fetch

cocoon1787.tistory.com

 

 

 

 

 

반응형
반응형
/**
 * const plus = (a, b) => a + b;
 * const minus = (a, b) => a - b;
 * const divide = (a, b) => a / b;
 *
 * -----------------------------------------
 * [Export Whole Thing] export default {plus, minus, divide};
 * [just one] export default plus;
 *
 * --------------- how to import ----------------------
 * [Export Whole Thing]import math_plus from "./math.mjs";
 * [just one] import math_plus from "./math.mjs";
 *
 * [Export Whole Thing] console.log(math_plus.plus(5, 4));
 * [just one] console.log(math_plus(5, 4));
 */


/**
 * export const plus = (a, b) => a + b;
 * export const minus = (a, b) => a - b;
 * export const divide = (a, b) => a / b;
 *
 * -----------------------------------------
 * [Same As Above] export {plus, minus, divide}
 * [just one] export {plus}
 *
 * --------------- how to import ----------------------
 * import { plus, minus, divide } from "./math.mjs"; [just one]
 * import { plus } from "./math.mjs"; [just one]
 *
 * console.log(plus(5, 4));
 */
반응형
반응형

 

<!DOCTYPE html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<meta http-equiv="X-UA-Compatible" content="IE=edge">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<title>authentication</title>
</head>
<script src="https://code.jquery.com/jquery-3.6.2.js" integrity="sha256-pkn2CUZmheSeyssYw3vMp1+xyub4m+e+QK4sQskvuo4=" crossorigin="anonymous"></script>

<link rel="stylesheet" href="./resource/css/pattern_lock.css">
<script src="./resource/js/pattern_lock.js" charset="utf-8"></script>
<body>


	<!-- 패턴-->
	<svg class="patternlock" id="lock" viewBox="0 0 100 100">
		<g class="lock-actives"></g>
		<g class="lock-lines"></g>
		<g class="lock-dots">
			<circle cx="20" cy="20" r="2"/>
			<circle cx="50" cy="20" r="2"/>
			<circle cx="80" cy="20" r="2"/>
	 
			<circle cx="20" cy="50" r="2"/>
			<circle cx="50" cy="50" r="2"/>
			<circle cx="80" cy="50" r="2"/>
	 
			<circle cx="20" cy="80" r="2"/>
			<circle cx="50" cy="80" r="2"/>
			<circle cx="80" cy="80" r="2"/>
		</g>
    </svg>

	<button onClick="clearPattern()"> Clear </button>

</body>


<script>

	/** 패턴 핸들러 **/
	let lock = new PatternLock("#lock", {
		onPattern: (pattern) => {
			console.log(pattern); // 입력한 패턴 값

			if(pattern === 123){
				lock.success();
			}else{
				lock.error();
			}

		},
		vibrate: false // 진동 on / off
	});

	let clearPattern = () =>{
		lock.clear();
	}

	let getPattern = () =>{
		lock.getPattern();
	}

	
</script>

</html>

index.html

(function (factory) {
  var global = Function('return this')() || (0, eval)('this');
  if (typeof define === 'function' && define.amd) {
      // AMD. Register as an anonymous module.
      define(['jquery'], function($) {
          return factory($, global)
      });
  } else if (typeof exports === 'object') {
      // Node. Does not work with strict CommonJS, but
      // only CommonJS-like environments that support module.exports,
      // like Node.
      module.exports = factory(require('jquery'), global);
  } else {
      // Browser globals (global is window)
      global.PatternLock = factory(global.jQuery, global);
  }
}(function ($, window) {
  var svgns = 'http://www.w3.org/2000/svg'
  var moveEvent = 'touchmove mousemove'

  var scrollKeys = {
      37: true, // left
      38: true, // up
      39: true, // right
      40: true, // down
      32: true, // spacebar
      38: true, // pageup
      34: true, // pagedown
      35: true, // end
      36: true, // home
  };

  function vibrate() {
      navigator.vibrate = navigator.vibrate || navigator.webkitVibrate || navigator.mozVibrate || navigator.msVibrate;
      if (navigator.vibrate) {
          window.navigator.vibrate(25)
      }
  }

  function PatternLock(element, options) {
      let svg = $(element)
      let self = this
      let root = svg[0]
      let dots = svg.find('.lock-dots circle')
      let lines = svg.find('.lock-lines')
      let actives = svg.find('.lock-actives')
      var pt = root.createSVGPoint();
      let code = []
      let currentline
      let currenthandler

      options = Object.assign(PatternLock.defaults, options || {})

      svg.on('touchstart mousedown', (e) => {
          clear()
          e.preventDefault()
          disableScroll()
          svg.on(moveEvent, discoverDot)
          let endEvent = e.type == 'touchstart' ? 'touchend' : 'mouseup';
          $(document).one(endEvent, (e) => {
              end()
          })
      })

      // Exported methods
      Object.assign(this, {
          clear,
          success,
          error,
          getPattern,
      })

      function success() {
          svg.removeClass('error')
          svg.addClass('success')
      }

      function error() {
          svg.removeClass('success')
          svg.addClass('error')
      }

      function getPattern() {
          return parseInt(code.map((i) => dots.index(i)+1).join(''))
      }

      function end() {
          enableScroll()
          stopTrack(currentline)
          currentline && currentline.remove()
          svg.off(moveEvent, discoverDot)
          let val = options.onPattern.call(self, getPattern())
          if (val === true) {
              success()
          } else if (val === false) {
              error()
          }
      }

      function clear() {
          code = []
          currentline = undefined
          currenthandler = undefined
          svg.removeClass('success error')
          lines.empty()
          actives.empty()
      }

      function preventDefault(e) {
          e = e || window.event;
          if (e.preventDefault)
              e.preventDefault();
          e.returnValue = false;
      }

      function preventDefaultForScrollKeys(e) {
          if (scrollKeys[e.keyCode]) {
              preventDefault(e);
              return false;
          }
      }

      function disableScroll() {
          if (window.addEventListener) // older FF
              window.addEventListener('DOMMouseScroll', preventDefault, false);
          window.onwheel = preventDefault; // modern standard
          window.onmousewheel = document.onmousewheel = preventDefault; // older browsers, IE
          window.ontouchmove = preventDefault; // mobile
          document.onkeydown = preventDefaultForScrollKeys;
      }

      function enableScroll() {
          if (window.removeEventListener)
              window.removeEventListener('DOMMouseScroll', preventDefault, false);
          window.onmousewheel = document.onmousewheel = null;
          window.onwheel = null;
          window.ontouchmove = null;
          document.onkeydown = null;
      }

      function isUsed(target) {
          for (let i = 0; i < code.length; i++) {
              if (code[i] === target) {
                  return true
              }
          }
          return false
      }

      function isAvailable(target) {
          for (let i = 0; i < dots.length; i++) {
              if (dots[i] === target) {
                  return true
              }
          }
          return false
      }

      function updateLine(line) {
          return function(e) {
              e.preventDefault()
              if (currentline !== line) return
              let pos = svgPosition(e.target, e)
              line.setAttribute('x2', pos.x)
              line.setAttribute('y2', pos.y)
              return false
          }
      }

      function discoverDot(e, target) {
          if (!target) {
              let {x, y} = getMousePos(e)
              target = document.elementFromPoint(x, y);
          }
          let cx = target.getAttribute('cx')
          let cy = target.getAttribute('cy')
          if (isAvailable(target) && !isUsed(target)) {
              stopTrack(currentline, target)
              currentline = beginTrack(target)
          }
      }

      function stopTrack(line, target) {
          if (line === undefined) return
          if (currenthandler) {
              svg.off('touchmove mousemove', currenthandler)
          }
          if (target === undefined) return
          let x = target.getAttribute('cx')
          let y = target.getAttribute('cy')
          line.setAttribute('x2', x)
          line.setAttribute('y2', y)
      }

      function beginTrack(target) {
          code.push(target)
          let x = target.getAttribute('cx')
          let y = target.getAttribute('cy')
          var line = createNewLine(x, y)
          var marker = createNewMarker(x, y)
          actives.append(marker)
          currenthandler = updateLine(line)
          svg.on('touchmove mousemove', currenthandler)
          lines.append(line);
          if(options.vibrate) vibrate()
          return line
      }

      function createNewMarker(x, y) {
          var marker = document.createElementNS(svgns, "circle")
          marker.setAttribute('cx', x)
          marker.setAttribute('cy', y)
          marker.setAttribute('r', 6)
          return marker
      }

      function createNewLine(x1, y1, x2, y2) {
          var line = document.createElementNS(svgns, "line")
          line.setAttribute('x1', x1)
          line.setAttribute('y1', y1)
          if (x2 === undefined || y2 == undefined) {
              line.setAttribute('x2', x1)
              line.setAttribute('y2', y1)
          } else {
              line.setAttribute('x2', x2)
              line.setAttribute('y2', y2)
          }
          return line
      }

      function getMousePos(e) {
          return {
              x: e.clientX || e.originalEvent.touches[0].clientX,
              y :e.clientY || e.originalEvent.touches[0].clientY
          }
      }

      function svgPosition(element, e) {
          let {x, y} = getMousePos(e)
          pt.x = x; pt.y = y;
          return pt.matrixTransform(element.getScreenCTM().inverse());
      }
  }


  PatternLock.defaults = {
      onPattern: () => {},
      vibrate: true,
  }


  return PatternLock
}));

pattern_lock.js

 

svg.patternlock g.lock-lines line {
    stroke-width: 1.5;
    stroke: black;
    opacity: 0.5;
}

svg.patternlock g.lock-dots circle {
    stroke: transparent;
    fill: black;
    stroke-width: 13.5;
}

svg.patternlock g.lock-actives circle {
    fill: black;
    opacity: .2;
    animation: lock-activate-dot .15s 0s ease 1;
    transform-origin: center;
}

svg.patternlock g.lock-lines line {
    stroke-width: 1.5;
    stroke-linecap: round;
}

svg.patternlock.success g.lock-actives circle {
    fill: green;
}

svg.patternlock.error g.lock-actives circle {
    fill: red;
}

@keyframes lock-activate-dot {
    0% {
        transform: scale(0);
    }
    75% {
        transform: scale(1.1);
    }
    100% {
        transform: scale(1.0);
    }
}

pattern_lock.css

 

성공
실패

출처 : https://github.com/tympanix/pattern-lock-js

 

GitHub - tympanix/pattern-lock-js: An android inspired pattern lock in scalable vector graphics and pure javascript

An android inspired pattern lock in scalable vector graphics and pure javascript - GitHub - tympanix/pattern-lock-js: An android inspired pattern lock in scalable vector graphics and pure javascript

github.com

 

자세한 문서는 위에 깃허브 참조하시면 됩니다.

반응형
반응형

ajax로 받아온 데이터 jstl에서 사용하고 싶을 시

 

웹페이지 구동 순서는 JAVA(Controller) > JSTL > HTML > JavaScript 순이기 때문에

ajax로 받아온다한들 JSTL부분이 앞에 있어서 화면에 받아온 데이터를 다시 그려주질 못한다.

 

그래서 내가 생각하기에는 SPA를 구현할거면 ajax만 이용하고 MPA의 경우는 JSTL만 사용하는게 올바르다.

 

MPA를 SPA로 다 뜯어고치기 힘든 경우라면 이런 방법을 추천한다.

 

1. ajax로 다시 그려줄 부분을 jsp로 뺀다.

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>
<html>
<head>
	<title>Home</title>
</head>
<body>
<h1>
	Hello world! My Name is ${name}  
</h1>

<P>  The time on the server is ${serverTime}. </P>

<button> 현재 시각을 동적으로 가져옵니다. </button>

</body>
</html>

원본 JSP

 

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>
<html>
<head>
	<title>Home</title>
</head>
<body>
<script src="https://code.jquery.com/jquery-3.6.2.js" integrity="sha256-pkn2CUZmheSeyssYw3vMp1+xyub4m+e+QK4sQskvuo4=" crossorigin="anonymous"></script>
<h1>
	Hello world! My Name is ${name}  
</h1>

<div id='ajaxRendering'>
	<P>  The time on the server is ${serverTime}. </P>
</div>

<button onClick=getTime()> 현재 시각을 동적으로 가져옵니다. </button>
	
</body>

<script>

	function getTime() {
		$.ajax({
			url: "/ajax",
			type: 'GET',
			success: function(result){
				$("#ajaxRendering").html(result);
			}	
		
		}); //ajax end	
	} 
</script>
</html>

원본 수정한 페이지 (button으로 ajax 렌더링하는 부분 및 그려줄 부분을 뺐다.)

 

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>
<html>

<P>  The time on the server is ${serverTime}. </P>

</body>
</html>

ajax로 그려주는 페이지

 

 

2. Controller에서 다시 그려줄 부분을 뺀 jsp를 호출한다.

package com.lsj.spring_study;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * Handles requests for the application home page.
 */
@Controller
public class AjaxController {
	/** ajax로 호출할 페이지 **/
	@RequestMapping(value = "/ajax", method = RequestMethod.GET)
	public String ajaxPage(Model model) {
		
        Date now = new Date();
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String nowTime = sdf1.format(now);
		
		model.addAttribute("serverTime", nowTime);
		
		return "ajax";
		
	}
	
    	/** 원본 페이지 **/
	@RequestMapping(value = "/origin", method = RequestMethod.GET)
	public String originPage(Model model) {
        
		
        Date now = new Date();
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String nowTime = sdf1.format(now);
		
		model.addAttribute("name", "마이클");
		model.addAttribute("serverTime", nowTime);
		
		return "origin";
		
	}

	
}

3. 본 페이지에서 해당 버튼을 클릭시 ajax를 호출한다.

 

origin이라는 URL 호출시 나오는 화면 (JSTL로 현재시각을 받아오려면 해당 URL을 호출해야함 → 새로고침)

 

버튼 클릭 후 네트워크 통신해서 다시 그려준 화면

 

 

 

 

 

 

출처 : https://my-t-space.tistory.com/47

반응형
반응형
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<script src="https://code.jquery.com/jquery-3.6.2.js" integrity="sha256-pkn2CUZmheSeyssYw3vMp1+xyub4m+e+QK4sQskvuo4=" crossorigin="anonymous"></script>
<body>

    <div id="Ahistory">
        Ahistory (뒤로가기가 존재합니다.)
    </div>

    <div id="Bhistory">
        Bhistory (뒤로가기가 존재하지 않습니다.)
    </div>
</body>

<script>

$('#Ahistory').click(() =>{
    location.href = 'https://www.naver.com';
});

$('#Bhistory').click(() =>{
    location.replace('https://www.naver.com');
});

</script>
</html>

 

반응형