자바스크립트 자료구조(JavaScript Data Structure) 공부_2 Array

 

자바스크립트 자료구조(JavaScript Data Structure)_ Chapter 2

 

 

  Arrays(배열)

- 가장 흔한 자료구조

- 인덱스를 가지는 복수의 자료를 저장

- 인덱스를 사용하여 자료에 접근 가능

 

 

 

   배열 생성

// 배열 선언하기
var numbers = [];

// 빈 배열의 길이는 0
print(numbers.length);  // display 0

// 값 넣어서 배열 선언하기
var numbers = [1, 2, 3, 4, 5];
print(numbers.length);  // display 5 (길이 5)

// 배열 선언하기2
var numbers = new Array();
print(numbers.length);  // display 0

// 값 넣어서 배열 선언하기2
var numbers = new Array(1, 2, 3, 4, 5);
print(numbers.length);  // display 5

// 특정 길이 배열 선언하기
var numbers = new Array(10);  // 길이가 10인 배열 선언
print(numbers.length);  // display 10

// 서로 다른 타입의 데이터가 한 배열에 들어갈 수 있다.
var objects = [1, "joe", true, null];

// Array.isArray() 함수 : 객체가 배열이면 true, 아니면 false 반환
var number = 3;
var arr = [8, 4, 1];
print(Array.isArray(number));  // display false
print(Array.isArray(arr));  // display true

1.  

 

 

 

 

   배열 요소 접근

// loop문으로 배열 요소에 접근
var nums = [];
for (var i = 0; i<100; ++i) {
	nums[i] = i+1;
}

// 배열 인덱스 활용하여 배열 요소에 접근
var numbers = [1, 2, 3, 4, 5];
var sum = numbers[0] + numbers[1] + numbers[2] + numbers[3] + numbers[4]
// var sum = 1 + 2 + 3 + 4 + 5;
print(sum); //  display 15

// loop문으로 배열 요소에 접근2
var numbers = [1, 2, 3, 5, 8, 13, 21];
var sum = 0;
for (var i = 0; i < numbers.length; ++i) {
	sum += numbers[i];
}
print(sum); // display 53

 

 

   문자열에서 배열 생성

// 문자열.split() : 문자열 분할 함수
var sentence = "the quick brown fox jumped over the lazy dog";
var words = sentence.split(" "); //  띄어쓰기로 문자 분할
for (var i = 0; i < words.length; ++i) {
	print("word " + i + ": " + words[i]);
}

// output
// word 0: the
// word 1: quick
...
// word 8: dog

 

 

   배열 집계

// 배열 할당
var nums = [];
for (var i = 0; i < 10; ++i) {
	nums[i] = i+1;
}
var samenums = nums;

// 원래 배열 변경 시 할당한(복사된) 배열도 같이 변경
var nums = [];
for (var i = 0; i < 10; ++i) {
	nums[i] = i+1;
}
var samenums = nums;
nums[0] = 400; // 원래 배열 변경
print(samenums[0]); //  display 400 (할당된/복사된 배열도 같이 변경)

// => shallow copy(얕은 복사) : 참조값 복사

// deep copy(깊은 복사) : 배열의 요소값들을 복사
function copy(arr1, arr2) {
	for (var i = 0; i < arr1.length; ++i) {
    	arr2[i] = arr1[i];
    }
}

var nums = [];
for (var i = 0; i < 100; ++i) {
	nums[i] = i+1;
}
var samenums = [];
copy(nums, samenums);
nums[0] = 400;
print(samenums[0]); //  display 1 (nums[0]의 값인 1이 복사되었기 때문)

// print() : 배열의 원소 출력
var nums = [1, 2, 3, 4, 5];
print(nums);

// output
// 1, 2, 3, 4, 5

 

 

   값 찾기

// indexOf() : 인자로 주어진 값과 같은 값을 가지는 인덱스 반환, 해당 인자가 없으면 -1 반환
var names = ["David", "Cynthia", "Raymond", "Clayton", "Jennifer"];
puststr("Enter a name to search for: ");
var name = readline();
var positioin = names.indesOf(name);
if (position >= 0) {
	print("Found " + name + " at position " + position);
}
else {
	print(name + " not found in array.");
}

// Cynthia 입력 시
// Found Cynthia at position 1

// Joe 입력 시
Joe not found in array.

// indexOf() : 만약에 해당 인자가 배열에 여러 개 있는 경우 첫 번째 인덱스를 반환
// lastIndexOf() : 인자를 배열의 뒤에서부터 찾아 첫번째로 발견되는 인덱스 반환, 해당 인자가 없는 경우 -1 반환
var names = ["David", "Mike", "Raymond", "Mike"];
var name = "Mike";
var firstPos = names.indexOf(name);
print("First found " + name + " at position " + firstPos);
var lastPos = names.lastIndexOf(name);
print("Last found " + name + " at position " + lastPos);

// output
// First found Mike at position 1
// Last found Mike at position 3

// 배열을 문자열로 반환 : join(), toString()
var name = ["David", "Cynthia", "Raymond"];
var namestr = names.join();
print(namestr); // David, Cynthia, Raymond
namestr = names.toString();
print(namestr); // David, Cynthia, Raymond

//print() : 배열을 출력하면 자동적으로 toString()으로 출력
print(names); // David, Cynthia, Raymond

 

 

   배열로 새로운 배열 만들기

// concat() : 2개 또는 그 이상의 배열로 하나의 배열 만들기
var cisDept = ["Mike", "Clayton", "Terrill"];
var dmpDept = ["Raymond", "Bryan"];
var itDiv = cisDept.concat(dmpDept);
print(itDiv); // Mike, Clayton, Terrill, Raymond, Bryan
itDiv = dmpDept.concat(cisDept);
print(itDiv); // Raymond, Bryan, Mike, Clayton, Terrill


// splice() : 배열의 요소로 새로운 배열 만들기 +) 배열에 요소를 추가 또는 삭제
var itDiv = ["Mike", "Clayton", "Terrill", "Raymond", "Bryan", "Danny", "Jennifer"];
var dmpDept = itDiv.splie(3, 3);
var cisDept = itDiv;
print(dmpDept); // Raymond, Bryan, Danny
print(cisDept); // Mike, Clayton, Terrill, Jennifer

 

 

   Mutator(변경자) 함수

// 배열에 요소 추가 : push(), unshift()

// push() : 배열의 끝에 요소 추가
var nums = [1, 2, 3, 4, 5];
print(nums); // 1, 2, 3, 4, 5
nums.push(6);
print(nums); // 1, 2, 3, 4, 5, 6

// length 이용하여 배열에 요소 추가
var nums = [1, 2, 3, 4, 5];
print(nums); // 1, 2, 3, 4, 5
nums[nums.length] = 6;
print(nums); // 1, 2, 3, 4, 5, 6

// 배열의 요소 하나씩 이동
var nums = [2, 3, 4, 5];
var newnum = 1;
var N = nums.length;
for (var i = N; i >= 0; --i) {
	nums[i] = nums[i-1]
}
nums[0] = newnum;
print(nums); // 1, 2, 3, 4, 5

// unshift() : 배열의 앞에 요소 추가
var nums = [2, 3, 4, 5];
print(nums); // 2, 3, 4, 5
var newnums = 1;
nums.unshift(newnum);
print(nums); // 1, 2, 3, 4, 5
nums = [3, 4, 5];
nums.unshift(newnum, 1, 2);
print(nums); // 1, 2, 3, 4, 5

// 배열에 요소 제거 : pop(), shift()

// pop() : 배열의 끝에 요소 제거, 제거되는 요소 반환
var nums = [1, 2, 3, 4, 5, 9];
print(nums); // 1, 2, 3, 4, 5, 9
nums.pop();
print(nums); // 1, 2, 3, 4, 5

// 배열의 요소 하나씩 이동
var nums = [9, 1, 2, 3, 4, 5];
print(nums); // 9, 1, 2, 3, 4, 5
for (var i = 0; i < nums.length; ++i) {
	nums[i] = nums[i+1]
}
print(nums); // 1, 2, 3, 4, 5

// shift() : 배열의 앞에 요소 제거, 제거되는 요소 반환
var nums = [9, 1, 2, 3, 4, 5];
nums.shift();
print(nums); // 1, 2, 3, 4, 5

// pop(), shift() : 제거되는 요소 반환
var nums = [6, 1, 2, 3, 4, 5];
var fisrt = nums.shift(); // 제거되는 요소 6 반환
nums.push(first);
print(nums); // 1, 2, 3, 4, 5, 6

 

 

  배열의 중간에 요소 추가, 제거

// splice(start index, number of element to remove(0:추가), elements of add) : 요소 추가, 제거
var nums = [1, 2, 3, 7, 8, 9];
var newElements = [4, 5, 6];
nums.splice(3, 0, newElements);
print(nums); // 1, 2, 3, 4, 5, 6, 7, 8, 9

var nums = [1, 2, 3, 7, 8, 9];
nums.splice(3, 0, 4, 5, 6);
print(nums);

var nums = [1, 2, 3, 100, 200, 300, 400, 4, 5];
nums.splice(3, 4);
print(nums); // 1, 2, 3, 4, 5

 

 

  배열 정렬

// reverse() : 배열 요소의 순서를 역순으로 반환
var nums = [1, 2, 3, 4, 5];
nums.reverse();
print(nums); // 5, 4, 3, 2, 1

// sort() : 배열의 요소를 정렬
var names = ["David", "Mike", "Bryan"];
nums.sort();
print(nums); // Bryan, David, Mike

var nums = [3, 1, 2, 100, 4, 200];
nums.sort();
print(nums); // 1, 100, 2, 200, 3, 4

// => 숫자를 크기대로 정렬하기 위해서 compare() 함수 필요
function compare(num1, num2) {
	return num1 - num2;
}
var nums = [3, 1, 2, 100, 4, 200];
nums.sort(compare);
print(nums); // 1, 2, 3, 4, 100, 200

 

 

  Iterator(반복자) 함수

// forEach() : 배열내의 모든 요소를 인자로 주어진 함수 실행
function square(num) {
	print(num, num * num);
}
var nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
nums.forEach(square);

// output
// 1 1
// 2 4
...
// 10 100


// every() : 배열내의 모든 요소를 인자로 주어진 함수로 테스트하여 참일 경우 true 반환
function isEven(num) {
	return num % 2 == 0;
}
var nums = [2, 4, 6, 8, 10];
var even = nums.every(isEven);
if (even) {
	print("all numbers are even");
}
else {
	print("not all numbers are even");
}

// output
// all numbers are even


// some() : 배열내의 요소를 인자로 주어진 함수를 테스트하여 하나라도 참인 경우 true 반환
function isEven(num) {
	return num % 2 == 0;
}
var nums = [1, 3, 5, 7, 9];
var someEven = nums.some(isEven);
if (someEven) {
	print("some numbers are even");
}
else {
	print("no numbers are even");
}

// output
// no numbers are even


// reduce() : 인자로 주어진 함수를 모든 요소에 적용하여 단일 값 반환, 왼쪽에서 오른쪽으로 진행
function add(runningTotal, currentValue) {
	return runningTotal + currentValue;
}

var nums = [1, 2, 3, 4, 5];
var sum = nums.reduce(add);
print(sum); // 15
// add(1, 2) -> add(3, 3) -> add(6, 4) -> add(10, 5) -> 15


// reduceRight() : reduce()와 동일, 하지만 오른쪽에서 왼쪽으로 진행
function concat(accumulatedString, item) {
	return accumulatedString + item;
}
var words = ["the ", "quick " "brown ", "fox "];
var sentence = words.reduceRight(concat);
print(sentence); // fox brown quick the

// map() : forEach() 함수로 나오는 값들을 배열로 반환
function curve(grade) {
	return grade += 5;
}
var grades = [77, 65, 81];
var newgrades = grades.map(curve);
print(newgrades); // 82, 70, 86

function first(word) {
	return word[0];
}
var words = ["for", "your", "information"];
var acronym = words.map(first);
print(acronym.join("")); // fyi


// fileter() : every() 함수와 비슷, 참인 요소를 배열로 반환
function isEven(num) {
	return num % 2 == 0;
}
function isOdd(num) {
	return num % 2 != 0;
}
var nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var evens = nums.filter(isEven);
print("Even numbers: " + evens); // Even number: 2, 4, 6, 8, 10
var odds = nums.filter(isOdd);
print("Odd numbers: " + odds); // Odd number: 1, 3, 5, 7, 9

function afterc(str) {
	if (str.indexOf("cie") > -1) {
		return true;
    }
    return false;
}
var words = ["recieve", "deceive", percieve", "deceit"];
var misspelled = words.filter(afterc);
print(misspelled); // recieve, percieve

 

 

  2차원과 다차원 배열

// 2차원 배열 생성 : n rows and 1 column
// #1
var twod = [];
var rows = 5;
for (var i = 0; i < rows; ++i) {
	twod[i] = [];
}

// #2
Array.matrix = function(numrows, numcols, initial) {
	var arr = [];
    for (var i = 0; i < numros; ++i) {
    	var columns = [];
        for (var j = 0; j < numcols; ++j) {
        	columns[j] = initial;
        }
        arr[i] = columns;
    }
    return arr;
}
var nums = Array.matrix(5, 5, 0)
print(nums[1][1]); // 0

// #3
var grades = [[89, 77, 78], [76, 82, 81]];
print(grades[1][1]); // 82

// 2차원 배열 요소 Process
var grades = [[89, 77, 78], [76, 82, 81], [91, 94, 89]];
var total = 0;
var agerage = 0.0;
for (var row = 0; row < grades.length; ++row) {
	for (var col = 0; col < grades[row].length; ++col) {
    	total += grades[row][col];
    }
    average = total / grades[row].length;
    print("Student " + parseInt(row+1) + " average: " + average.toFixed(2));
    total = 0;
    average = 0.0;
}
// output
// Student 1 average: 81.33
// Student 2 average: 79.67
// Student 3 average: 91.33


var grades = [[89, 77, 78], [76, 82, 81], [91, 94, 89]];
var total = 0;
var agerage = 0.0;
for (var col = 0; col < grades.length; ++col) {
	for (var row = 0; row < grades[col].length; ++row) {
    	total += grades[row][col];
    }
    average = total / grades[col].length;
    print("Test " + parseInt(col+1) + " average: " + average.toFixed(2));
    total = 0;
    average = 0.0;
}
// output
// Test 1 average: 85.33
// Test 2 average: 84.33
// Test 3 average: 82.67

// Jagged Arrays(가변 배열) : row마다 요소의 수가 다름
var grades = [[89, 77], [76, 82, 81], [91, 94, 89, 99]];
var total = 0;
var agerage = 0.0;
for (var row = 0; row < grades.length; ++row) {
	for (var col = 0; col < grades[row].length; ++col) {
    	total += grades[row][col];
    }
    average = total / grades[row].length;
    print("Student " + parseInt(row+1) + " average: " + average.toFixed(2));
    total = 0;
    average = 0.0;
}
// output
// Student 1 average: 83.00
// Student 2 average: 79.67
// Student 3 average: 93.25

 

 

  배열과 객체

function Point(x, y) {
	this.x = x;
    this.y = y;
}
function displayPts(arr) {
	for (var i = 0; i < arr.length; ++i) {
    	print(arr[i].x + ", " + arr[i].y);
	}
}
var p1 = new Point(1, 2);
var p2 = new Point(3, 5);
var p3 = new Point(2, 8);
var p4 = new Point(4, 4);
var points = [p1, p2, p3, p4]; // 객체가 배열의 요소가 될 수 있음
for (var i = 0; i < points.length; ++i) {
	print("Point " + parseInt(i+1) + ": " + points[i].x + ", " + points[i].y);
}
var p5 = new Point(12, -3);
points.push(p5);
print("After push: ");
displayPts(points);
points.shift();
print("After shift: ");
displayPts(points);

// output
// Point 1: 1, 2
// Point 2: 3, 5
// Point 3: 2, 8
// Point 4: 4, 4
// After push:
// 1, 2
// 3, 5
// 2, 8
// 4, 4
// 12, -3
// After shift:
// 3, 5
// 2, 8
// 4, 4
// 12, -3

function weekTemps() {
	this.dataStore = [];
    this.add = add;
    this.average = average;
}
function add(temp) {
	this.dataStore.push(temp);
}
function average() {
	var total = 0;
    for (var i = 0; i < this.dataStore.length; ++i) {
    	total += this.dataStore[i];
    }
    return total / this.dataStore.length;
}
var thisWeek = new weekTemps();
thisWeek.add(52);
thisWeek.add(55);
thisWeek.add(61);
thisWeek.add(65);
thisWeek.add(55);
thisWeek.add(50);
thisWeek.add(52);
thisWeek.add(49);
print(thisWeek.average()); // 54.875