developer_rooney.log

[Java] Stream API - 2

Sun, 23 Apr 2023 16:08:57 GMT

Stream API

Stream 중간 연산 요약

분류	상세 분류	설명
Stream 필터	filter(), distinct()	- filter()는 구성한 스트림 내에서 특정 조건에 맞는 결과값을 필터링 하기 위해 사용됩니다. - distinct()는 구성한 스트림 내에서 중복을 제거한 결과값을 반환하기 위해 사용됩니다.
Stream 변환	map(), flatMap()	- map()은 구성한 스트림 내에서 요소들을 원하는 값으로 변환하여서 반환하기 위해 사용됩니다. - flatMap()는 구성한 스트림 내에서 중복된 스트림을 평면화(flattern)하여 요소를 구성하여 반환하기 위해 사용됩니다.
Stream 제한	limit(), skip()	- limit()는 구성한 스트림 내에서 요소의 개수를 제한하여 반환해주기 위한 목적으로 사용됩니다. - skip()는 구성한 스트림 내에서 시작부터 특정 n개의 요소를 제외하여 반환해주는 목적으로 사용합니다.
Stream 정렬	sorted()	- sorted()는 구성한 스트림 내에서 배열 혹은 리스트 그리고 Object의 요소에 대해서 오름/내림 차순을 수행하여 반환해주는 함수입니다.
Stream 연산 결과 확인	peek()	- peek()는 구성한 스트림 내에서 각각의 요소를 조회하는 연산자료 요소 자체를 추출하는것이 아닌 스트림의 요소를 조회하는 함수입니다.

Stream 중간 연산 상세

Stream 필터 - filter()

Stream 내에서 특정 조건에 맞는 결과값을 필터링 하기 위해 사용됩니다.

/*
* [CASE1] Array 이용한 방법
*/
// 1. Array Initialize
int[] filterIntArr = {100, 200, 300, 500};

// 2. Array to IntStream : 300 이상의 값 filter IntStream filterIntStream = Arrays.stream(filterIntArr).filter(item -> item >= 300);

// 3. IntStream to Array filterIntArr = filterIntStream.toArray(); // 결과값 반환 : [300, 500]

[CASE2] ArrayList 이용한 방법
/ // 1. ArrayList Initialize List filterStrList = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung"));

// 2. ArrayList to Stream : 리스트 내에 "lee"가 존재하는 배열을 찾습니다. Stream filterStrStream = filterStrList.stream().filter(item -> item.equals("lee"));

// 3. Stream to ArrayList filterStrList = filterStrStream.collect(Collectors.toList()); // 결과값 반환 : ["lee", "lee"]

[CASE3] Object 이용한 방법
/ // 1. Object ArrayList Initialize List
filterUserDtoList = Arrays.asList(
```
  UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
  UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("A").build()
```
); // 2. Object to Stream : 사용자 상태가 "S"인 Object 를 찾습니다. Stream filterUserDtoStream = filterUserDtoList.stream().filter(item -> item.getUserSt().equals("S"));

// 3. Stream to ArrayList filterUserDtoList = filterUserDtoStream.collect(Collectors.toList()); // 결과값 반환: List 2




## Stream 필터 - distinct()
- Stream 내에서 중복을 제거한 결과값을 반환하기 위해 사용됩니다.
```java
/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] distinctIntArr = {1000, 5000, 5000, 7000, 12000, 12000};

// 2. Array to IntStream : Array 내에 중복되는 요소 제거
IntStream distinctIntStream = Arrays.stream(distinctIntArr).distinct();

// 3. InputStream to Array
distinctIntArr = distinctIntStream.toArray();    // 결과값 반환 : [1000, 5000, 7000, 12000]

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List distinctStrList = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung"));

// 2. Array to IntStream : ArrayList 내에 중복되는 요소 제거
Stream distinctStrStream = distinctStrList.stream().distinct();

// 3. InputStream to Array
distinctStrList = distinctStrStream.collect(Collectors.toList());    // 결과값 반환 : ["kim", "lee", "park", "jung"]

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List distinctUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("S").build()
);

// 2. Object to Stream : 객체간의 중복되는 요소를 확인.
Stream distinctUserDtoStream = distinctUserDtoList.stream().distinct();

// 3. Stream to ArrayList
distinctUserDtoList = distinctUserDtoStream.collect(Collectors.toList());   // 결과값 반환: 동일한 객체가 아니므로 구성한 모든 객체가 리스트로 반환이 됩니다.

Stream 변환 - Map()

Stream 내에서 요소들을 원하는 값으로 변환하여서 반환하기 위해 사용합니다.
요소 내에서 조건부 검색을 위한 목적으로 사용하는 filter와 다르게 요소를 조작하여서 반환을 해줍니다.

/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] mapIntArr = {1000, 5000, 7000, 12000};

// 2. Array to IntStream : 배열 요소 값이 7000 이상일 경우에만 3000을 더해서 반환합니다.
IntStream mapIntStream = Arrays.stream(mapIntArr).map(item -> item >= 7000 ? item + 3000 : item);

// 3. InputStream to Array
mapIntArr = mapIntStream.toArray();    // 결과값 반환 : [1000, 5000, 10000, 15000]

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List mapStrList = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung"));

// 2. ArrayList to Stream
Stream strMapStream = mapStrList.stream().map(item -> "name ::" + item);

// 3. Stream to ArrayList
mapStrList = strMapStream.collect(Collectors.toList());      // 결과값 반환 : ["name ::kim", "name ::lee", "name ::park", "name ::lee", "name ::jung"]

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List mapUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("S").build()
);
// 2. Object to Stream
Stream userDtoMapStream = mapUserDtoList.stream().map(item -> {
    return item.toBuilder().userNm("MyName is " + item.getUserNm()).build();
});

// 3. Stream to ArrayList
mapUserDtoList = userDtoMapStream.collect(Collectors.toList()); // 결과값 반환: List 2

// map을 이용한 소문자를 대문자로 전환 작업
String[] toLowerCaseArr = {"one", "two", "three"};
Stream upperCaseStream = Arrays.stream(toLowerCaseArr).map(String::toUpperCase);

Stream 변환 - flatMap()

Stream 내에서 중복된 Stream을 평면화하여 요소를 구성하여 변환하기 위해 사용됩니다. 중복된 구조의 리스트를 하나의 평면화된 리스트로 반환을 받습니다.
```
/*
* [CASE1] 2차원 int Array 이용한 방법
*/
// 1. 2차원 intArray Initialize
int[][] int2Dimension = {{1, 2}, {3, 4}, {5, 6}};
```

// 2. 2차원 intArray to 1차원 intArray int[] flatMapIntArr = Arrays.stream(int2Dimension).flatMapToInt(Arrays::stream).toArray(); // 결과값 반환: [1, 2, 3, 4, 5, 6]

[CASE2] 2차원 string Array 이용한 방법
/ // 1. 2차원 stringArray Initialize String[][] str2Dimension = {{"one", "two"}, {"three", "four"}, {"five", "six"}};

// 2. 2차원 stringArray Initialize to 1차원 object Array Object[] flatMapObjectArr = Arrays.stream(str2Dimension).flatMap(Arrays::stream).toArray(); // 결과값 반환: ["one, "two", "three", "four", "five", "six")





## Stream 제한 - limit()
- Stream 내에서 요소의 개수를 제한하여 반환해 주기 위한 목적으로 사용됩니다.
```java
/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] limitIntArr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 2. Array to IntStream : 4개의 요소만 출력되도록 한다.
IntStream limitIntStream = Arrays.stream(limitIntArr).limit(4);

// 3. InputStream to Array
limitIntArr = limitIntStream.toArray(); // [1, 2, 3, 4]

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List limitStrList = new ArrayList<>(Arrays.asList("one", "two", "three", "four", "five"));

// 2. ArrayList to Stream
Stream limitStrStream = limitStrList.stream().limit(4);

// 2. InputStream to Array
limitStrList = limitStrStream.collect(Collectors.toList());     // ["one", "two", "three", "four"]

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List limitUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("S").build(),
        UserDto.userBuilder().userId("fjdsl3").userNm("park").userPw("5678").userSt("S").build(),
        UserDto.userBuilder().userId("jklasd").userNm("jung").userPw("8765").userSt("S").build()
);
// 2. Object to Stream
Stream limitUserDtoStream = limitUserDtoList.stream().limit(2);

// 3. Stream to ArrayList
limitUserDtoList = limitUserDtoStream.collect(Collectors.toList()); // 결과값 반환: List 2

Stream 제한 - skip()

Stream 내에서 시작부터 특정 n개의 요소를 제외하여 반환해 주는 목적으로 사용합니다.
```
/*
* [CASE1] Array 이용한 방법
*/
// 1. Array Initialize
int[] skipIntArr = {1, 2, 3, 4, 5, 6, 7, 8};
```

// 2. Array to IntStream : 배열 내에서 인덱스 순서대로 2개의 값을 제외한 결과값을 반환합니다. IntStream skipIntStream = Arrays.stream(skipIntArr).skip(2);

// 3. InputStream to Array skipIntArr = skipIntStream.toArray(); // [3, 4, 5, 6, 7, 8]

[CASE2] ArrayList 이용한 방법
/ // 1. ArrayList Initialize List skipStrList = new ArrayList<>(Arrays.asList("one", "two", "three", "four", "five"));

// 2. InputStream to Array : 리스트 내에서 인덱스 순서대로 4개의 값을 제외한 결과값을 반환합니다. Stream skipStrStream = skipStrList.stream().skip(4);

// 3. InputStream to Array skipStrList = skipStrStream.collect(Collectors.toList()); // ["five"]

[CASE3] Object 이용한 방법

/ // 1. Object ArrayList Initialize List skipUserDtoList = Arrays.asList(

  UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
  UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("S").build(),
  UserDto.userBuilder().userId("fjdsl3").userNm("park").userPw("5678").userSt("S").build(),
  UserDto.userBuilder().userId("jklasd").userNm("jung").userPw("8765").userSt("S").build()

); // 2. Object to Stream : 리스트 내에서 인덱스 순서대로 2개의 값을 제외한 결과값을 반환합니다. Stream skipUserDtoStream = skipUserDtoList.stream().skip(2);

// 3. Stream to ArrayList skipUserDtoList = skipUserDtoStream.collect(Collectors.toList()); // 결과값 반환: List 2




## Stream 제한 - sorted()
- Stream 내에서 배열 혹은 리스트, Object의 요소에 대해서 오름/내림 차순을 수행하여 반환해 주는 함수입니다.
```java
/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] sortNumArr1 = {10, 11, 1, 2, 4};
int[] sortNumArr2 = {0, 1, 2, 3, 4};

// 2.1. Array to IntStream : 배열을 오름차순으로 정렬합니다.
IntStream sortAscIntStreamType1 = Arrays.stream(sortNumArr1).sorted();

// 2.2. Array to Stream : 배열을 내림차순으로 정렬합니다.
Stream sortDescIntStreamType1 = Arrays.stream(sortNumArr1).boxed().sorted(Comparator.reverseOrder());
Stream sortDescIntStreamType2 = Arrays.stream(sortNumArr2).boxed().sorted((a, b) -> b - a);

// 3.1. IntStream to int[]
int[] resultSortedNumArr1 = sortAscIntStreamType1.toArray();    // 결과값 반환(오름차순) : [1, 2, 4, 10, 11]

// 3.2. Stream to int[]
int[] resultSortedNumArr2 = sortDescIntStreamType1.mapToInt(i -> i).toArray();      // 결과값 반환(내림차순) : [11, 10, 4, 2, 1]
int[] resultSortedNumArr3 = sortDescIntStreamType2.mapToInt(i -> i).toArray();      // 결과값 반환(내림차순) : [4, 3, 2, 1, 0]

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List sortedStrList1 = new ArrayList<>(Arrays.asList("aaa", "bbb", "ccc", "ddd", "AAA"));
List sortedStrList2 = new ArrayList<>(Arrays.asList("apple", "banana", "cherry"));
List sortedStrList3 = new ArrayList<>(Arrays.asList("f", "b", "z"));

// 2.1. ArrayList to Stream : 리스트를 오름 차순으로 정렬합니다.
Stream sortedStrStream1 = sortedStrList1.stream().sorted(Comparator.naturalOrder());

// 2.2. ArrayList to Stream : 리스트를 오름 차순으로 정렬합니다.
Stream sortedStrStream2 = sortedStrList2.stream().sorted(Comparator.reverseOrder());
Stream sortedStrStream3 = sortedStrList3.stream().sorted((a, b) -> b.compareTo(a));

// 3.1. Stream to List
sortedStrList1 = sortedStrStream1.collect(Collectors.toList());     // 결과값 반환(오름차순) : ["AAA", "aaa", "bbb", "ccc", "ddd"]
sortedStrList2 = sortedStrStream2.collect(Collectors.toList());     // 결과값 반환(오름차순) : ["cherry", "banana", "apple"]
sortedStrList3 = sortedStrStream3.collect(Collectors.toList());     // 결과값 반환(오름차순) : ["z", "f", "d"]

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List sortedUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("S").build(),
        UserDto.userBuilder().userId("fjdsl3").userNm("park").userPw("5678").userSt("S").build()
);

// 2.1. Object to Stream : 리스트 내에서 userNm을 기준으로 오름차순으로 정렬합니다.
Stream sortedAscUserDtoStream = sortedUserDtoList.stream().sorted(Comparator.comparing(UserDto::getUserNm));

// 2.2. Object to Stream : 리스트 내에서 userNm을 기준으로 내림차순으로 정렬합니다.
Stream sortedDescUserDtoStream = sortedUserDtoList.stream().sorted(Comparator.comparing(UserDto::getUserNm).reversed());

// 3. Stream to ArrayList
List sortedAscUserDtoList = sortedAscUserDtoStream.collect(Collectors.toList());           // 결과값 반환: List
List sortedDescUserDtoList = sortedDescUserDtoStream.collect(Collectors.toList());         // 결과값 반환: List

Stream 연산 결과 확인 - peek()

Stream 내에서 각각의 요소를 조회하는 연산자로 요소 자체를 추출하는 것이 아닌 Stream의 요소를 조회하는 함수입니다.
해당 값은 스트림 그대로 변환하기에 다시 객체 형태로 변환이 불가능합니다.
peek() 함수를 사용하여 디버깅과 디버깅을 위한 중간 연산 결과값을 확인 가능합니다.

/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] peekIntArr = {10, 11, 1, 2, 4};

// 2. Array to IntStream
IntStream peekIntStream = Arrays.stream(peekIntArr)
        .peek(System.out::println)
        .map(i -> i + 10)
        .peek(i -> System.out.println("결과값 : " + i))
        .map(i -> i + 10);

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List peekStrList = new ArrayList<>(Arrays.asList("apple", "banana", "cherry"));

// 2. Array to Stream
Stream peekStrStream = peekStrList.stream()
        .peek(System.out::println)
        .map(i -> "My " + i)
        .peek(i -> System.out.println("결과값 : " + i))
        .map(i -> i + " 입니다");

[Java] Stream API - 1

Sun, 23 Apr 2023 14:24:16 GMT

Stream API

Stream의 정의

Stream API는 Lambda Expression을 이용한 기술 중 하나로 데이터 소스를 조작 및 가공, 변환하여 원하는 값으로 반환해주는 interface 입니다.
해당 기능을 사용하기 위해서는 Java 1.8 이상의 버전을 사용해야 합니다.
해당 Stream interface는 java.util.stream에 포함되어 있습니다.

Stream 타입 별 객체의 종류

분류	타입	Stream Type
정수형	byte	Stream
정수형	short	Stream
정수형	int	IntStream
정수형	long	LongStream
문자형	char	Stream
실수형	float	Stream
실수형	double	DoubleStraem
문자열	String	Stream
논리형	boolean	Stream

Stream의 특징

1. 원본 데이터를 변경하지 않습니다.

Stream API는 원본 데이터를 조회하여 별도의 Stream 객체로 생성합니다.
그렇기에 배열의 정렬이나 필터링 작엄을 하더라도 원본 데이터를 변경하지 않습니다.

2. 재사용이 불가능하여 일회용으로 사용됩니다.

Stream API는 이미 사용이 되어 닫혔다면 재사용이 불가능합니다.

3. 내부 반복으로 작업을 처리합니다.

Stream 내에서 내부적으로 반복문을 처리하기에 간결한 소스코드의 작성이 가능합니다.

Stream의 과정

Stream 객체를 구성하고자 할때에 "Stream 생성 -> 중간 연산 -> 최종 연산"의 세 단계의 과정을 통해 처리가 이루어 집니다.

Object.Stream().middle().final()

1. Stream 생성

분류	상세 분류
Stream 생성	empty stream
Stream 생성	Collection
Stream 생성	Array
Stream 생성	Stream.builder()
Stream 생성	Stream.generate()
Stream 생성	Stream.Iterator()
Stream 생성	기본 타입 스트림
Stream 생성	파일 스트림

2. 중간연산

분류	상세 분류
Stream 필터	filter(), distinct()
Stream 변환	map(), flatMap()
Stream 제한	limit(), skip()
Stream 정렬	sorted()
Stream 연산 결과 확인	peek()

3. 최종연산

분류	상세 분류
요소의 출력	forEach()
요소의 검색	findFirst(), findAny()
요소의 검사	anyMatch(), allMatch(), noneMatch()
요소의 통계	count(), min(), max()
요소의 연산	sum(), average()
요소의 수집	collect()

Stream - 생성

// 요소 값이 존재하지 않는 빈 스트림 객체를 생성
Stream emptyStream = Stream.empty();

// 컬렉션 값이 존재하는 스트림 객체 생성
List strList = new ArrayList<>(Arrays.asList("a","b","c","d"));
Stream strStream = strList.stream();

// 배열 값이 존재하는 스트림 객체를 생성
String[] strArr = {"a", "b", "c", "d"};
Stream strStream2 = Arrays.stream(strArr);

Stream strStream3 = Stream.of(strArr);

Stream strStream4 = Stream.of("one", "two", "three");

// 빌더로 구성한 요소값들로 스트림 객체를 구성할 때
Stream builderStream = Stream.builder()
    .add("a")
    .add("b")
    .add("c")
    .add("d")
    .build();

// generate() 함수내에서 람다(Lambda)로 값을 지정하여 스트림을 구성할 때 사용
// 해당 스트림은 제한을 두지 않으면 무한으로 생성되기에 최대 크기를 지정해야합니다.
Stream generatedStream = Stream.generate(() -> "abcd").limit(3); // ["abcd","abcd","abcd",]

// iterate() 함수 내에서 람다(Lambda)로 값을 지정하여 스트림을 구성할 때 사용
Stream iteratedStream = Stream.iterate(70, (n) -> n + 10).limit(3) // [70, 80, 90]

// 기본타입(int, long, double)으로 값을 지정하여 스트림을 구성할 때 사용
IntStream intStream = IntStream.range(1,5);
LongStream longStream = LongStream.rangeClosed(1,5);
DoubleStream doubleStream = DoubleStream.iterate(100, (n) -> n+10).limit(3);

// 파일 타입(File)을 요소값으로 지정하여 스트림을 구성할 때 사용
Stream fileToStrStream = Files.lines(Paths.get("file.txt"), Charset.forName("UTF-8"));

참고자료

JavaScript - 타입 변환(2)

Wed, 18 May 2022 07:29:26 GMT

기본 데이터 타입 래퍼 객체

var s = "wayne rooney";
var sNum = s.length;

위 코드의 첫 줄은 s가 문자열이지만, 두 번째 줄에서 length라는 프로퍼티가 사용되, s는 객체로 느껴지기도 한다.

이는 자바스크립트에는 세 가지 핵심 기본 데이터 타입(숫자, 문자열, 불리언 데이터타입) 각각에 대응되는 클래스 (String, Number, Boolean) 가 정의되어 있기 때문에 문맥상 일치하는 클래스로 자동 변환되어 프로퍼티를 사용할 수 있게 된다.

즉, 문자열을 객체 문맥으로 사용하면 내부적으로 문자열에 대한 String 객체가 자동으로 사용된다.

객체 문맥에서 문자열을 사용할 때 생성되는 String 객체는 일시적으로 존재하는 것이다. String 객체의 프로퍼티와 메서드에 대한 접근이 완료되면 이 객체는 더 이상 필요하지 않으므르 시스템이 객체를 회수해 간다.

위 코드에서 문자열 s의 값은 변하지 않으며, 새로운 임시 객체인 String 객체가 생성된 후 문자열의 길이를 sNum 변수에 저장하고 임시 객체는 사라진다.

문자열과 마찬가지로 숫자, 불리언 데이터타입에서도 같은 동작을 한다.

객체에서 기본 타입으로 변환

객체는 기본 타입으로 손쉽게 변환이 된다. 먼저 NULL이 아닌 객체가 불리언 문맥에서 사용되면 true로 변환된다.

new Boolean(false) // 내부 값은 false이지만 객체는 true 반환한다.
그 이유는 객체가 null이 아니기 때문이다.

값의 변환은 그 값이 사용되는 문맥에 따라 이루어진다. (+)연산자와 비교연산자는 숫자와 문자열 둘 다에 대해 작동한다. 따라서 객체가 이 연산자들 중 하나와 함께 객체가 이 연산자들 중 하나와 함께 사용될 경우, 숫자로 변환되어야 하는지 문자열로 변환되어야 하는지가 명확하지 않다.

대부분의 경우 자바스크립트는 객체의 valueOf() 메서드를 호출하여 객체를 변환하고, 이 메서드가 기본 데이터 타입 값을 반환하면 그 값이 사용된다.

그러나 종종 valueOf()가 단순히 변환되지 않은 객체를 반환할 수도 있다. 이때는 자바스크립트는 toString() 메서드를 호출하여 객체를 문자열로 변환하려고 시도한다.

이 경우에도 예외가 있는데 Date 객체와 +연산자를 사용하면 toString() 메서드가 먼저 사용된다.

*참고자료 : 자바스크립트 완벽 가이드 5/E

JavaScript - 타입 변환 요약

Sun, 08 May 2022 18:09:38 GMT

자바스크립트는 필요에 따라 그 값을 변환한다. 문맥에 따라 여러가지 값들을 자동으로 변환시켜준다.

표를 참고하자.

값	문자열 문맥	숫자 문맥	불리언 문맥	객체 문맥
undefined	"undefined"	NaN	false	Error
null	"null"	0	false	Error
빈 문자열이 아닌 문자열	그 자체	나타내는 숫자 or NaN	true	String 객체
빈 문자열	그 자체	0	false	String 객체
0	"0"	그 자체	false	Number 객체
NaN	"NaN"	그 자체	false	Number 객체
무한대	"Infinity"	그 자체	true	Number 객체
음의 무한대	"Infinity"	그 자체	true	Number 객체
기타 숫자	숫자를 문자열로 표현	그 자체	true	Number 객체
true	"true"	1	그 자체	Boolean 객체
false	"false"	0	그 자체	Boolean 객체
object	toString()	ValueOf(), toString(), NaN	true	그 자체

JavaScript - 배열

Sat, 07 May 2022 16:05:43 GMT

배열

배열(array)은 객체처럼 데이터 값들의 모음이다. 객체 내에 포함되는 각 데이터 값에는 이름이 있는 반면, 배열의 각 데이터 값에는 번호, 즉 인텍스가 있다.

배열 이름 다음에 대괄호로 둘러싸인 인덱스를 써주어서 배열로부터 값을 가져올 수 있다.

배열은 다른 배열이나 객체, 함수를 포한한 어떤 자바스크립트 데이터 타입의 데이터라도 담을 수 있다.

document.images[1].width

이 코드는 document 객체의 images 배열에 두 번째 원소로 저장된 객체의 width 프로퍼티를 가리킨다.

일반적인 배열은 음수가 아닌 정수로 인덱싱된다. 반면에 연관 배열은 문자열로 인덱싱 된다. 자바스크립트는 타입의 제약이 없는 언어이므로, 자바 언어처럼 배열의 원소들이 모두 동일한 타입을 가질 필요는 없다.

배열 생성

배열은 Array() 생성자 함수로 생성할 수 있다. 일단 배열을 생성하고 나면, 배열의 어떤 인덱스에라도 얼마든지 엘리먼트를 할당할 수 있다.

var a = new Array();
a[0] = 1.2;
a[1] = "javascript";
a[2] = true;
a[3] = {x:1, y:3};

배열 원소들을 Array() 생성자에 넘겨주어 배열을 초기화할 수도 있다. 때문에 앞의 배열 생성과 초기화 코드는 다음과 같이 재작성 할 수 있다.

var a = new Array(1.2, "javaScript", true, {x:1, y:3});

Array() 생성자에 숫자 하나를 넘겨주면 그 숫자는 배열의 크기로 사용된다.

var a = new Array(10); // 10의 크기를 가진 a 배열 생성

배열 리터럴

배열 리터럴은 대괄호로 둘러싸인 쉼표로 구분된 값들의 목록이다. 객체 리터러러럼 중첩될 수도 있다. 또한 객체 리터럴과 마찬가지로 배열 리터럴 내 요소로 임의의 표현식이 올 수 있으며 반드시 상수일 필요는 없다.

var a = [1.2, "javaScript", true, {x:1, y:3}];

var b = [[1,2,3],[4,5,6,],[7,8,9]];

var base = 1024;
var table = [base+1, base+2, base+3];

***참고자료 : 자바스크립트 완벽 가이드 5/E**

JavaScript - 객체

Sat, 07 May 2022 15:13:37 GMT

객체

객체는 이름 붙은 값들의 모음이다. 보통 이 이름 붙은 값들을 객체의 프로퍼티라고 부른다. 객체 프로퍼티를 참조하려면 객체 이름을 쓰고 이어서 마침표와 프로퍼티 이름을 적어주면 된다.

예를 들어 image라는 이름의 객체에 width와 height라고 이름 붙은 프로퍼티 두 개가 있다면 다음과 같은 방식으로 이 프로퍼티들을 참조할 수 있다.

image.width
image.height

함수가 객체 프로퍼티로 저장될 경우 그 함수를 흔히 메서드라고 부른다. 이 경우 객체 프로퍼티의 이름은 메서드 이름이 된다.

객체 메서드를 호출할 때는 객체로부터 함수 값을 추출하기 위해 .을 사용하고 함수를 호출하기 위해()를 사용한다. 예를 들어, document라는 객체의 wrute() 메서드를 호출하려면 다음과 같이 코드를 작성하면된다.

document.write("ROONEY");

자바스크립트에서 객체는 연관 배열의 역할도 수행한다. 즉, 객체는 임의의 문자열에 임의의 값을 연결한다. 객체가 이러한 방식으로 사용될 경우 객체 프로퍼티에 접근할 때는 다른 문법을 사용한다. 이 때는 접근하려는 프로퍼티 이름을 나타내는 문자열을 대괄호로 둘러싸면 된다.

image["width"]
image["geight"]

연관 배열은 많은 프로그래밍 기법에서 효과적으로 사용될 수 있는 데이터 타입이다. 조금 더 공부하고 설명해보도록 하겠다.

객체 생성

객체는 특수한 생성자 함수를 호출하여 샹성할 수 있다. 다음 몇 줄은 모두 객체를 생성하는 코드를 보여준다.

var O = new object();
var now = new Date();
var Patter = new RegExp("\\sjava\\s","i");

일단 여러분이 원하는 객체를 생성하고 나면 마음대로 객체를 사용하고 프로퍼티 값을 설정할 수 있다.

var point = new Object();
point.x = 2.3;
point.y = -1.2;

객체 리터럴

자바스크립트는 객체를 생성하고 프로퍼티를 지정하는 객체 리터럴 문법을 제공한다. 객체 리터럴은 콜론으로 구별되는 프로퍼티 이름/값 쌍들이 다시 쉼표로 분리된 목록이다. 따라서 앞에서 본 point 객체를 다음과 같이 생성하고 초기화 할 수 있다.

var point = {x:2.3, y:-1.2};

객체 리터럴 내에서 사용되는 프로퍼티 값이 상수일 필요는 없다. 프로퍼티 값으로 임의의 자바스크립트 표현식을 사용할 수 있다. 또한 객체 리터럴 내의 프로퍼티 이름으로 식별자 뿐만 아니라 문자열도 사용할 수 있다.

var square = { "upperLeft": {x:point.x, y:point.y}, 
               'lowerRight': {x:point.x + side, y: point.y + side}};

*참고자료 : 자바스크립트 완벽 가이드 5/E

JavaScript - 함수

Sat, 07 May 2022 14:35:44 GMT

함수

함수는 자바스크립트 프로그램에 정의되어 있거나 자바스크립트 구현에 미리 정의되어 있는 실행 가능한 코드 이며, 한 번 정의하면 자바스크립트 프로그램 내에서 여러 번 실행될 수 있다.

함수는 계산 대상인 값들을 지정하는 전달인자나 매개변수를 넘겨받을 수 있으며, 계산 결과를 나타내는 값을 반환할 수 있다.

함수는 자신이 새롭게 정의할 수도 있고, 자바스크립트에서 Matr.sin() 함수 같이 정해놓은 함수를 활용할 수도 있다.

function rooney(x) // 함수 이름은 rooney이며 전달인자 x 하나를 받는다.
{                    // 함수의 몸체 시작
    return x+3;       // 이 함수는 전달인자에 3을 더한 값을 반환한다.
}                   // 함수의 몸체 종료

함수가 정의되면 함수 이름과 괄호를 사용하여 함수를 호출 할 수 있다.

X = Math.sin();
Y = rooeny(2);

자바스크립트의 중요한 특성 중 하나는 함수도 자바스크립트 코드로 조작할 수 있는 형태의 값이라는 것이다. 이것은 함수를 변수나, 배열, 객체에 저장할 수 있으며 다른 함수의 전달인자로 넘겨 줄 수 있다는 것을 의미한다.

함수도 숫자나 문자열 처럼 값이므로 다른 값처럼 객체 프로퍼티에 할당될 수 있다. 함수가 어떤 객체의 프로퍼티로 할당되면, 흔히 그 객체의 메서드라고 부른다.

함수 리터럴

함수 리터럴은 함수 이름을 명시하지 않는다는 것을 제외하고는 함수 정의와 모양이 동일하다.

function park(x) { return x*2;} // park 함수 정의

var park = function(x) {return x*2;} // park 함수 리터럴

이름 없는 함수를 람다함수라고 부른다. 고급 스크립트를 작성할 때 함수 리터럴이 꽤나 편리하고 유용하게 사용될 수 있다.

함수를 정의하는 방법은 한 가지 더 있다. 전달인자 목록과 함수 몸체를 문자열 형태로 Function() 생성자에 전달하는 것이다.

var park = new Function("x", "return x*2;");

하지만 이런식으로 정의하면 비효율적이다.

*참고자료 : 자바스크립트 완벽 가이드 5/E

JavaScript - boolean

Thu, 05 May 2022 08:45:30 GMT

불리언 값

불리언 데이터 타입은 두 개의 값을 가지고 있다. true or false. 불리언 값은 진리값을 나타내며 무언가가 참인지 거짓인지를 말해준다. 일반적으로 불리언 값은 자바스크립트 프로그램에서 비교의 결과로 생성된다.

    a == 1 // 이 코드는 변수 a의 값이 1과 같은지 검사하며, 같다면 true 다르면 false가 된다.

불리언 타입 변환

불리언 값은 다른 타입으로 변환되거나 다른 타입에서 불리언 값으로 변환될 수 있으며 대부분 자동으로 수행된다. 숫자 문맥에서는 true는 1, false는 0으로 변환되며 문자열 문맥에서는 true는 "true", false는 "false"로 변환된다.

명시적 타입 변환으로는 Boolean() 함수를 사용할 수 있다.

var boo = Boolean();

*참고자료 : 자바스크립트 완벽 가이드 5/E

JavaScript - 문자열(2)

Thu, 05 May 2022 08:26:07 GMT

   > ## 문자열 조작

숫자에 + 연산을 적용하면 숫자들이 더해지지만, 문자열에 적용하면 두 번째 문자열을 첫 번째 문자열에 이어 붙여 두 문자열을 합친다.

three = "two" + "plus" + "one"; // "two plus one"

숫자를 문자열로 변환

숫자는 필요할 때 문자열로 자동으로 변환된다. 문자열을 이어붙이는 표현식에서 숫자가 사용될 경우 숫자는 문자열로 변환된다.

var n = 13;
var s = n + "park"; // "13 park"

n + ""; // "13" 숫자에 빈 문자열을 더하면 숫자열을 문자열로 바꿀 수 있다.

이 방법 이외에도 명시적으로 숫자를 문자열로 바꾸는 String() 함수, 숫자를 문자열로 변환하는 toString() 메서드를 사용하는 방법이 있다.

var a = String(number);
var b = number.toString(기수); // 기수: 2,8,10,16 진법, 10진법은 생략가능

문자열을 숫자로 변환

문자열이 숫자 문맥에 사용되면 자동으로 숫자로 변환된다. 곱하기나 빼기에는 문자열이 숫자로 인식되어 연산이 되지만, 더하기 연산에서는 문자열로 인식된다.

var ABC = "10" * "20"; // 200
var bbc = "1030" - 0; // 1030

var ccd = "1234" + 0; // "1234" 더하기에는 문자열로 인식됨

숫자를 문자열로 변환하는 것과 마찬가지로 명시적으로 Number() 함수를 사용하거나 parseInt() 또는 parsefloat() 메서드를 사용할 수도 있다.

var num = Number("1223"); // 1223
parseInt("32") // 32
parseInt("32.1 rooney") // 32, 숫자가 아닌 문자는 무시
parseInt("12.33 rooney") // 12.33

*참고자료 : 자바스크립트 완벽 가이드 5/E

JavaScript - 문자열 (1)

Thu, 05 May 2022 08:15:05 GMT

문자열

문자열은 Unicode 문자나 숫자, 문장부호들의 시퀀스로 텍스트를 표현하는 자바스크립트 데이터 타입이다. C, C++, Java와는 다르게 char 같은 문자 테이터 타입을 가지고 있지 않다.

단일 문자를 표현하려면 길이가 1인 문자열을 사용하면 된다.

"a" // 단일 문자
"abc" // 문자열

문자열 리스트

작은 따옴표(''), 큰 따옴표("")로 문자열을 나타내며, 따옴표들은 서로 포함 해줄 수 있다. 문자열 리터럴은 한 줄을 넘지 말아야 하며, 문자열 리터럴 내에서 줄바꿈을 실행하고 싶다면 \n (역슬래시 + n)을 사용한다.

"" // 빈 문자열
"abc"
'abc'
"name = 'rooney'"
'name = "rooney"'
"hello, my name is rooney \n see you later!"// \n을 기준으로 열이 바뀌면서 출력됨

따옴표의 순서는 상관없지만 영어의 축약형 표현들 he's 라던지 isn't 등에 들어가는 작은 따옴표를 사용할 경우, 자바스크립트에서는 문자열을 구분하는 작은따옴표로 인식하게 된다. 이 때는 이스케이프(역슬래시) 시퀀스를 사용하여 작은따옴표를 문자열로 인식하게 해준다.

"he's good man. i'll vote him." // => he's good man. i'll vote him.

'he's good man. i'll vote him.' // => 오류발생

'he\'s good man. i\'ll vote him.' // => he's good man. i'll vote him. 이스케이프 문자 인식

이스케이프 시퀀스

\0  //널 문자
\b  //백스페이스
\t  //수평 탭 
\n  //줄바꿈 문자
\v  //수직 탭
\f  //폼 피드
\r  //케리지 리턴
\"  //큰 따옴표
\'  //작은 따옴표
\\  //역 슬래시

*참고자료 : 자바스크립트 완벽 가이드 5/E

JavaScript - 숫자(2)

Mon, 25 Apr 2022 14:44:23 GMT

숫자 조작

자바스크립트에서 제공하는 산술 연산자를 사용하여 숫자를 다룰 수 있다. 산술 연산자에는 우리가 흔히 하는 더하기(+), 빼기(-), 곱하기(*), 나누기(/)가 있다.

그 이외에도 자바스크립트가 제공하는 많은 수의 수리 함수를 하용해 한층 더 복잡한 수리 연산을 수행할 수 있다. 이 함수들은 Math라는 객체를 사용하여 접근 가능하다.

sine_of_x = Math.sin(x); // 숫자 x의 사인 값을 계산

hypot = Math.sqrt(x*x + y*y); // 숫자 표현식의 제곱근

특수한 값

부동소수점 값으로 표현 가능한 가장 큰 유한 수보다 더 큰 값은 Infinit로 반환된다. 음수 값보다 더 작은 무한대는 -Infinity로 반환된다. 수리 연산에서 정의되지 않은 결과값은 NaN이 반환된다.

그 외의 특수한 값

상수	의미
Infinity	무한대를 나타내는 값
NaN	숫자가 아닌 값
Number.Max_Value	표현 가능한 가장 큰 수
Number.MIN_Value	표현 가능한 가장 작은 수
Number.NaN	숫자가 아닌 특수한 값
Number.POSITIVE_Value	양의 무한대를 표현하는 특수한 값
Number.NEGATIVE_Value	음의 무한대를 표현하는 특수한 값

메모장을 이용한 자바스크립트 작성

출력 내용

*참고 자료: 자바스크립트 완벽 가이드 5/E

JavaScript - 숫자(1)

Mon, 25 Apr 2022 10:44:22 GMT

가장 기본이되는 데이터 타입

자바스크립트는 정수 값과 실수 값을 구별하지 않는다는 점에서 C나 Java같은 프로그램 언어와 다르다.

모든 숫자는 실수로 표현된다. ± 1.7976931348623157 x 10^308 만큼 크고, ± 5 x 10^(-324)만큼 작은 숫자를 표현할 수 있다.

정수 리터럴

자바스크립트에서 10진수 정수는 숫자 시퀀스 형태로 작성된다.

시퀸스란? sequence, 연속된 숫자나 문자를 의미한다.

0
3
100000

자바스크립트 숫자형식은 -9007199254740992(-2^53) ~ 9007199254740992(2^53) 사이에 있는 모든 정수를 표현할 수 있다. 이보다 더 큰 정수를 사용하면 낮은 자리 수에 대한 정밀도를 잃는다.

자바스크립트에서 몇몇 정수 연산자들은 -2147483648(-2^31)에서 2147483647((2^31)-1)에 이르는 32비터 정수에 대해서만 작동한다.

16진수와 8진수

10진수 리터럴 이외애도 자바스크립트는 16진수 값을 인식한다. 16진수 리터럴은 '0x'나 '0X'로 시작하고 16진수 숫자들이 뒤따르는 형태다. 16진수 숫자는 0~~9와 10부터 15까지를 표현하는 A~~F의 문자를 사용한다.

0xff // 15*16 + 15 = 255(10진수)

0xCAFE911

몇몇 자바스크립트 구현에서는 정수 리터럴을 8진수로도 표현할 수 있게 지원한다. 8진수 리터럴은 숫자 0으로 시작되고 0부터 7사이의 숫자 시퀸스가 뒤따르는 형태이다.

0377 // 3*64 + 7*8 + 7 = 255(10진수)

구현하는 자바스크립트와 그렇지 않은 자바스크립트가 있으므로 0으로 시작하는 정수리터럴 사용은 지양하자.

부동소수점 리터럴

부동소수점 리터럴은 소수점을 가질 수 있다. 실수는 정수 부분과 소수점, 소수점 이하 부분으로 표현된다.

지수 표기법을 사용하여 부동소수점 리터럴을 표현할 수도 있다.

3.14
2345.789
.33333
6.02E23 // 60.2 xx 10^23
1.4738223E-32 // 1.4738223 xx 10^-32

실수는 무한 개 존재하지만 자바스크립트에서는 제한된 개수만 표현할 수 있다.

*참고자료 : 자바스크립트 완벽 가이드 5/E