검색결과 리스트
Swfit에 해당되는 글 14건
- 2017.08.04 14. 딕셔너리 (Dictionary)
- 2017.08.04 13. Swift 구조체와 클래스
- 2017.08.04 12. Swift 클로저(Closure)
- 2017.08.04 11. Swift 함수의 중첩
- 2017.08.04 10. Swift 일급 객체로서의 함수
- 2017.08.04 9. Swift 매개변수 1
- 2017.08.04 8. Swift 함수(Function)
- 2017.08.04 7. Swift 옵셔널 (Optional)
- 2017.08.04 6. Swift 튜플 (Tuple)
- 2017.08.04 5. Swift 집합 (Sets)
글
14. 딕셔너리 (Dictionary)
Swfit
2017. 8. 4. 12:11
14. 딕셔너리 (Dictionary)
- 고유 키 (Key) 와 귿에 대응하는 값(Value) 을 연결 하여 데이터를 저장하는 자료형이다. 인덱스 정수 대신 문자열 등의 고유 키를 사용한다는 차이를 제외 하면 배열과 아주 흡사하다.
[ 키 : 데이터 , 키 : 데이터 , …..]
- 하나의 키는 하나의 데이터에만 연결되어야 한다.
- 하나의 딕셔너리에서 키는 중복될 수 없다. 중복해서 선언하면 아이템 추가가 아니라 수정이 이루어져 기존 키에 연결된 데이터가 제거 된다.
- 저장할 수 있는 데이터 타입에는 제한이 없지만, 하나의 딕셔너리에 저장하는 데이터 타입은 모두 일치 해야 한다.
- 딕셔너리의 아이템에는 순서가 없지만 키에는 내부적으로 순서가 있으므로 for~in 구문을 이용한 순회 탐색을 할 수 있다.
- 딕셔너리에서 사용할 수 있는 키의 타입은 거의 제한이 없으나 해시 연산이 가능한 타입이어야 한다.
var capital = [“KR” : “Seoul” , “EN” : “London” , “FR” : “Paris”]
키
| 저장된 값
|
KR
| Seoul
|
EN
| London
|
FR
| paris
|
capital[“KR”] // “Seoul”
capital[“EN”] // “London”
capital[“FR”] // “Paris”
- 딕셔너리의 초기화
Dictionary<String, Int>() //문자열 키와 정수 값 딕셔너리
Dictionary<String, String>() //문자열 키와 문자열 값 딕셔너리
Dictionary<String, AnyObject>() //문자열 키와 범용 클래스 값으로 이루어진 딕셔너리
Dictionary<Character, String>() //문자 키와 문자열 값으로 이루어진 딕셔너리
- 딕셔너리의 선언과 초기화
var capital = Dictionary<String, String>( ) //방법 1
var capital = [String : String]( ) //방법 2
###################
var capital : Dictionary<String, String> //타입 이노베이션을 이용한 딕셔너리 선언
capital = Dictionary( ) //딕셔너리 초기화
###################
var capital : [string:String] //타입이노테이션을 이용한 딕셔너리 선언
capital = [String:String]( ) //딕셔너리 초기화
###################
//딕셔너리의 초기화
capital = Dictionary<String, String>( )
capital = Dictionary( )
capital = [String:String]( )
capital = [:]
- 딕셔너리에 동적 아이템 추가 하기
var newCapital = [String:String]( )
newCapital[“JP”] = "Tokyo"
print(newCapitall[“JP"])
// Tokyo
- 데이터 수정 하기
newCapital.updateValue(“okinawa”, forked:”JP”)
print(newCapitall[“JP”])
//출력 값 : okinawa
- 데이터 삭제 하기
newCapital[“JP”] = nil
print(newCapitall[“JP”])
//출력 값 : error
###################
newCapital.removeAll( ) // 딕셔너리의 모든 값 삭제
###################
newCapital.removeValue(forKey:”JP”) // JP 키 의 값 삭제
- 딕셔너리 순회탐색
for row in newCapital {
let (key , value) = row
print(“현재 데이터는 \(key) : \(value) 입니다.”)
}
// 출력
현재 데이터는 CA : Value = beijing 입니다
현재 데이터는 KR : Value = seoul 입니다
현재 데이터는 JP : Value = okinawa 입니다
###################
간결한 버전
for (key, value) in newCapital {
print(“현재 데이터는 \(key) : \(value) 입니다.”)
}
// 출력
현재 데이터는 CA : Value = beijing 입니다
현재 데이터는 KR : Value = seoul 입니다
현재 데이터는 JP : Value = okinawa 입니다
'Swfit' 카테고리의 다른 글
| 13. Swift 구조체와 클래스 (0) | 2017.08.04 |
|---|---|
| 12. Swift 클로저(Closure) (0) | 2017.08.04 |
| 11. Swift 함수의 중첩 (0) | 2017.08.04 |
| 10. Swift 일급 객체로서의 함수 (0) | 2017.08.04 |
| 9. Swift 매개변수 (1) | 2017.08.04 |
글
13. Swift 구조체와 클래스
Swfit
2017. 8. 4. 12:10
13. Swift 구조체와 클래스
* 기본개념 *
값을 저장할 수는 없지만 특정 기능을 실행할 수 있는 함수와, 값을 저장할 수 있지만 혼자서 특정 기능을 실행할 수는 없는 변수 상수의 특성을 모두모아놓았다고 이해하면 편하다.
- 구조체와 클래스의 공통점
- 프로퍼티
- 변수나 상수으를 사용하여 값을 저장하는 프로퍼티를 정의할 수 있다.
- 메소드
- 함수를 사용하여 기능을 제공하는 메소드를 정의할 수 있다.
- 서브스크립트
- 속성값에 접근할 수 있는 방법을 제공하는 서브스크립트를 정의할 수 있다.
- 초기화 블록
- 객체를 원하는 초기 상태로 설정해주는 초기화 블록을 정의할 수 있다.
- 확장
- 객체에 함수적 기능을 추가하는 확장(extends)구문을 사용할 수 있다.
- 프로토콜
- 특정 형식의 함수적 표준을 제공하기 위한 프로토콜을 구현할 수 있다.
- 구조체와 클래스의 차이점
- 상속
- 클래스의 특성을 다른 클래스에게 물려줄 수 있다.
- 타입 캐스팅
- 실행 시 컴파일러가 클래스 인스턴스의 타입을 미리 파악하고 검사할 수 있다.
- 소멸화 구문
- 인스턴스가 소별되기 직전에 처리해야 할 구문을 미리 등록해 놓을 수 있다.
- 참조에 의한 전달
- 클래스 인스턴스가 전달될 때에는 참조 형식으로 제공되며, 이때 참조가 가능한 개수는 제약이 없다.
//구조체의 정의 형식
struct 구조체_이름 {
// 구조체 정의 내용이 들어갈 구문
}
//클래스의 정의 형식
class 클래스_이름 {
// 클래스 정의 내용이 들어갈 구문
}
//카멜 표기법
- 구조체와 클래스 이름의 첫 글자는 대문자로, 나머지 글자는 소문자로 작성한다.
- 2개 이상의 복합 단어는 단어별로 끊어 첫 글자는 대문자로, 나머지는 소문자로 작성한다.
- 이미 축약된 약어는 모두 대문자로 작성 가능하다(ex: JSON, NS , HTTP 등)
- 프로퍼티나 메소드를 선언할 때는 소문자로 시작한다.
- 언더바로 단어를 연결하는 방식은 지양한다.
'Swfit' 카테고리의 다른 글
| 14. 딕셔너리 (Dictionary) (0) | 2017.08.04 |
|---|---|
| 12. Swift 클로저(Closure) (0) | 2017.08.04 |
| 11. Swift 함수의 중첩 (0) | 2017.08.04 |
| 10. Swift 일급 객체로서의 함수 (0) | 2017.08.04 |
| 9. Swift 매개변수 (1) | 2017.08.04 |
글
12. Swift 클로저(Closure)
Swfit
2017. 8. 4. 11:54
12. Swift 클로저(Closure)
- 클로저는 두 가지로 이루어진 객체이다. 하나는 내부 함수이며, 또 다른 하나는 내부 함수가 만들어진 주변 환경이다.
- 클로저는 외부 함수 내에서 내부 함수를 반환하고, 내부 함수가 외부 함수의 징역 변수나 상수를 참조할 때 만들어 진다.
- 클로저란 내부 함수와 내부 함수에 영향을 미치는 주변환경(Context)을 모두 포함한 객체이다
func basic(param : Int) -> (Int) -> Int{
//—————클로저 범위
let value = param + 20
func append(add : Int) -> INT {
return value + add
}
//———— 클로저 범위
return append
}
- 전역 함수 - 이름이 있으며, 주변 환경에서 캡쳐할 어떤 값도 없는 클로저
- 중첩 함수 - 이름이 있으며 자신을 둘러싼 함수로부터 값을 캡쳐할 수 있는 클로저
- 클로저 표현식 - 이름이 없으며 주변 환경으로부터 값을 캡쳐할 수 있는 경량 문법으로 작성된 클로저
//클로저 표현식
{(매개변수) -> 반환타입 in
실행할 구문
}
###################
let f = { () -> Void in
print(“클로저가 실행됩니다”)
}
f()
//클로저가 실행됩니다
###################
var value = [1, 9, 5, 7, 3, 2]
func order(s1:Int , s2:Int) -> Bool {
if s1 > s2 {
return true
} else {
return false
}
}
value.sort(by: order) // [9, 7, 5, 3, 2, 1]
*클로저 표현식으로 변경
{
(s1:Int, s2:Int) -> Bool in
if s1 > s2 {
return true
} else {
return false
}
}
value.sort(by:{s1:Int,s2:Int) ->Bool in return s1 > s2})
'Swfit' 카테고리의 다른 글
| 14. 딕셔너리 (Dictionary) (0) | 2017.08.04 |
|---|---|
| 13. Swift 구조체와 클래스 (0) | 2017.08.04 |
| 11. Swift 함수의 중첩 (0) | 2017.08.04 |
| 10. Swift 일급 객체로서의 함수 (0) | 2017.08.04 |
| 9. Swift 매개변수 (1) | 2017.08.04 |
글
11. Swift 함수의 중첩
Swfit
2017. 8. 4. 11:53
11. Swift 함수의 중첩
- 스위프트에서 함수는 중첩하여 작성할 수 있다. 함수 내에 다른 함수를 작성해서 사용할 수 있다. 이렇게 작성된 함수를 중첩함수라고 하고 , 중첩 함수를 부분별로 나누어 보면 함수 내에 작성된 함수는 내부 함수, 내부함수를 포함하는 바깥쪽 함수는 외부 함수 로 구분할수 있다.
- 함수내에 작성할 수 있는 내부 함수의 수에는 제한이 없다.
- 내부 함수 내에 또다른 내부 함수를 작성할 수도 있다.
- 내부 함수는 외부 함수가 실행되는 순간 생성되고, 종료되는 순간 소멸한다. 이것이 내부 함수의 생명 주기 이다.
//외부 함수
func outer(base : Int) -> String {
//내부 함수
func inner(inc : Int) -> String {
return "\(inc)를 반환합니다.”
}
let result = inner(inc : base + 1)
return result
}
outer(base: 3)
//“4를 반환합니다.”
###################
//외부 함수
func outer(param : Int) -> (Int) -> String {
//내부 함수
func inner(inc : Int) -> String {
return "\(inc)를 반환합니다.”
}
return inner
}
let fn1 = outer(param:3)
let fn2 = fn1(30)
'Swfit' 카테고리의 다른 글
| 13. Swift 구조체와 클래스 (0) | 2017.08.04 |
|---|---|
| 12. Swift 클로저(Closure) (0) | 2017.08.04 |
| 10. Swift 일급 객체로서의 함수 (0) | 2017.08.04 |
| 9. Swift 매개변수 (1) | 2017.08.04 |
| 8. Swift 함수(Function) (0) | 2017.08.04 |
글
10. Swift 일급 객체로서의 함수
Swfit
2017. 8. 4. 11:51
10. Swift 일급 객체로서의 함수
- 스위프트는 객체지향 언어이자 동시에 함수형 언어이다. 함수형 언어를 학습하게 되면 반드시 일급 객체 라는 용어를 접하게 되는데,이것은 크리스토퍼 스트래치 라는 영국의 컴퓨터 과학자가 1960년대에 처음 사용한 개념으로서, 프로그램 언어 안에서 특정 종류의 객체가 일급의 지위를 가지는가에 대한 의미이다.
- 일급 함수의 특성
- 객체가 런타임에도 생성이 가능해야 한다.
- 인자값으로 객체를 전달할 수 있어야 한다.
- 반환값으로 객체를 사용할 수 있어야 한다.
- 변수나 데이터 구조 안에 저장할 수 있어야 한다.
- 할당에 사용된 이름과 관계없이 고유한 구별이 가능해야 한다
- 변수나 상수에 함수를 대입할 수 있음
- 변수나 상수에 함수를 대입 한다는 것은 말 그대로 함수 자체를 변수에 집어넣는다는 뜻이며,이렇게 함수가 대입된 변수나 상수는 함수처럼 실행할 수도 있고,인자값을 입력받을수도 있다.반환값도 가질수 있다.
//정수를 입력 받는 함수
func foo(base:Int) -> String {
return “결과값은 \(base + 1)입니다”
}
let fn1 = foo(bee: 5)
// “결과값은 6 입니다."
let fn2 = foo //fn2 상수에 foo 함수가 할당 됨
fn2(5) // “결과값은 6입니다”
###################
func foo(base:Int) -> String {
print(“함수 foo 가 실행됩니다”)
return “결과값은 \(base + 1)입니다”
}
let fn3 = foo(base:5)
// 출력 함수 foo 가 실행됩니다
- 함수의 반환 타입으로 함수를 사용할 수 있음
- 일급 객체로 대우받는 함수는 실행 결과로 정수,실수,문자열 등의 기본 자료형이나 클래스, 구조체 등의 객체를 반환할 수 있을 뿐만 아니라 함수 자체를 반환할 수도 있다.
func desc() -> String {
return “This is desc()”
}
func pass() -> (Void) -> String {
return desc
}
let p = pass()
p()
// 출력 값
“this is desc()"
- 함수의 인자값으로 함수를 사용할 수 있음
- 함수를 인자값으로 전달할 때 그 함수는 하나의 타입이 된다. 따라서 함수를 입력받는 인자값은 함수 타입으로 정의되어야 한다. 이 점을 제외 하면 인자값으로 함수를 전달하는 방식에는 특별한 것이 없다.
func incr(param : Int) -> Int {
return param + 1
}
func broker(base : Int, function fn : (Int) -> Int) -> Int {
return fn(base)
}
broker(base:3 ,function:incr) // 4
- 콜백 함수
func successThrough() {
print(“연산 처리가 성공하였습니다.”)
}
func failThrough() {
print(“처리 과정에 오류가 발생하였습니다.”)
}
func divide(base : Int, success sCallBack : (Void) -> Void, fail fCallBack: (Void) -> Void) -> Int {
guard base != 0 else {
fCallBack() //실패 함수를 실행한다.
return 0
}
defer {
sCallBack() //성공 함수를 실행한다.
}
return 100 //base
}
divide(base : 30 , success : successThrough, fail : failThrough)
//함수 인자를 사용하여 콜백을 처리하고 있다.이 함수는 첫 번째 인자로 받은 정수를 사용하여 100 을 나누고 , 그 몫을 정수 형태로 반환하는 역활을 한다. 두번째 인자는 내부 연산 과정이 성공적으로 완료 되었을때 실행할 함수이며, 세 번째 인자는 내부 연산 과정이 실패 했을때 실행할 함수이다.
- defer 블록
- defer 블록은 작성된 위치와 순서에 상관없이 함수가 종료되기 직전에 실행된다.
- defer 블록을 읽기 전에 함수의 실행이 종료될 경우 defer 블록은 실행되지 않는다.
- 하나의 함수나 메소드 내에서 defer 블록을 여러 번 사용할 수 있다. 이때에는 가장 마지막에 작성된 defer 블록부터 역순으로 실행된다.
- defer 블록을 중첩해서 사용할 수 있다. 이때에는 바깥쪽 defer 블록부터 실행되며 가장 안쪽에 있는 defer 블록은 가장 마지막에 실행된다.
//defer는 주로 함수가 연산을 처리하는 과정에 영향을 끼치지 않으면서 실행해야 할 다른 내용이 있을 때 사용하거나 함수를 종료하기 직전에 정리해야 하는 변수나 상수값들을 처리하는 용도로 사용된다.
'Swfit' 카테고리의 다른 글
| 12. Swift 클로저(Closure) (0) | 2017.08.04 |
|---|---|
| 11. Swift 함수의 중첩 (0) | 2017.08.04 |
| 9. Swift 매개변수 (1) | 2017.08.04 |
| 8. Swift 함수(Function) (0) | 2017.08.04 |
| 7. Swift 옵셔널 (Optional) (0) | 2017.08.04 |
글
9. Swift 매개변수
Swfit
2017. 8. 4. 11:50
9. Swift 매개변수
- 내부 매개변수명, 외부 매개변수명
- 내부 매개변수 : 함수가 내부적으로 인자값을 참조하기 위해 사용하는 변수
- 외부 매개변수 : 함수 외부에서 함수나 인자값을 구분하기 위해 사용하는 변수
//내부 매개변수
func printHello(name : String, msg : String) {
print(“\(name)님, \(msg)”)
}
printHello(name:"홍길동" , msg:”안녕하세요")
//외부 매개변수
func printHello(to name : String,welcomeMessage msg : String) {
print(“\(name)님, \(msg)”)
}
printHello(to:"홍길동" , welcomeMessage:”안녕하세요")
- 가변 인자
//입력된 값들의 평균값을 계산하는 함수
func avg(score : Int… ) -> Double {
var total = 0 //정수 합계
for r in score { // 배열로 입력된 값들을 순회 탐색하면서 점수를 합산
total += r
}
return (Double(total) / Double(score.count)) //평균값을 구해서 반환
}
- In Out 매개변수
var cat = 30
func autoIncrement(value : Int) -> Int {
var value = value
value += 1
return value
}
print(autoIncrement(value:cnt)) // 함수 내부의 value 변수값 : 31
print(cat) // 외부에서 정의된 cnt 변수값 : 30
###################
//상수는 inout 매개변수에 인자 값으로 전달할 수 없음
let count1 = 30
autoIncrement(value:&count1)
//리터럴 inout 매개변수에 인자값으로 전달할 수 없음
autoIncrement(value:&30) // X
//변수는 inout 매개변수에 인자값으로 전달할 수 있음
var value = 30
autoIncrement(value:&value) // O : 31
'Swfit' 카테고리의 다른 글
| 11. Swift 함수의 중첩 (0) | 2017.08.04 |
|---|---|
| 10. Swift 일급 객체로서의 함수 (0) | 2017.08.04 |
| 8. Swift 함수(Function) (0) | 2017.08.04 |
| 7. Swift 옵셔널 (Optional) (0) | 2017.08.04 |
| 6. Swift 튜플 (Tuple) (0) | 2017.08.04 |
글
8. Swift 함수(Function)
Swfit
2017. 8. 4. 11:49
8. Swift 함수(Function)
- 함수의 기본 개념
- 동일한 코드가 여러 곳에서 사용될 때 이를 함수화하면 재작성할 필요 없이 함수 호출만으로 처리할 수 있다.
- 전체 프로세스를 하나의 소스 코드에서 연속적으로 작성하는 것보다 기능 단위로 함수화하면 가독성이 좋아지고, 코드와 로직을 이해하기 쉽습니다.
- 비지니스 로직을 변경해야 할 때 함수 내부만 수정하면 되므로 유지보수가 용이하다.
- 사용자 정의 함수
func 함수 이름(매개변수1:타입, 매개변수2:타입 …) -> 반환타입 {
실행 내용
return 반환 값
}
- 함수 정의
//매개변수와 반환값이 모두 없는 함수
func printHello() {
print(“안녕하세요”)
}
###################
//매개변수가 없지만 반환값은 있는 함수
func sayHello() -> String {
let returnValue = “안녕하세요”
return returnValue
}
###################
//매개변수는 있으나 반환값이 없는 함수
func printHelloWithName(name : String) {
print(“\(name)님, 안녕하세요”)
}
###################
//매개변수와 반환값이 모두 있는 함수
func sayHelloWithName(name:String) -> String {
let returnValue = “\(name)님 , 안녕하세요”
return returnValue
}
###################
//반환값이 없는 함수일때도 return 사용하는 경우는 함수의 실행을 명시적으로 종료할 목적으로 사용 된다.
func hello(name: String?) {
guard let _name = name else{
return
}
print(“\(_name)님, 안녕하세요”)
}
- 함수의 호출
printHello()
//printHello = 함수이름
//() = 함수호출 연산자
//입력된 (값 x 횟수)만큼 카운트 변수의 값을 증가
func incrementBy(amount:Int, numberOfTimes:Int) {
var count = 0
count = amount * numberOfTimes
}
###################
func times(x:Int, y:Int) -> Int {
return (x*y)
}
times(x:5 , y: 10) // 함수의 이름만으로 호출한 구문
times(x:y:)(5, 10) // 함수의 식별자를 사용하여 호출한 구문
// 스위프트 함수를 호출하는 방법은 함수명 + 괄호 + 인자값 이므로, 인자 레이블까지를 전체 함수의 이름으로 본다면 항상 times(x:y:)(5, 10) 형식으로 호출하는 것이 맞다. 하지만 실제로는 times 만으로 함수를 호출할 수 있으므로 times 는 함수의 이름으로 , times(x:y:)는 함수의 식별자로 보는 것이 조금더 적절 하다.
- 함수의 반환값과 튜플
// Int,String 으로 구성된 튜플을 반환하는 함수
func getIndvInfo() -> (Int,String) {
let height = 180
let name = “꼼꼼한 재은씨”
return(height , name)
}
###################
// Int,Character,String 으로 구성된 튜플을 반환하는 함수
func getUserInfo() -> (Int,Character,String) {
//데이터 타입이 String 으로 추론되는 것을 방지하기 위해 타입 어노테이션 선언
let gender : Character = “M”
let height = 180
let name = “꼼꼼한 재은씨”
return (height, gender, name)
}
###################
//튜플을 반환하는 함수의 반환값을 대입 받은 변수나 상수는 튜플의 인덱스를 이용하여 튜플 내부의 요소를 사용할 수 있습니다.
var uInfo = getUserinfo()
uInfo.0 // 180
uInfo.1 // “M"
uInfo.2 // “꼼꼼한 재은씨”
###################
//인덱스를 사용하는 대신 가독성과 편리성을 위해 튜플 요소 각각을 변수로 직접 받을 수도 있다.
var (a,b,c) = getUserInfo()
a // 180
b // “M”
c // “꼼꼼한 재은씨"
###################
//일부 필요하지 않은 튜플 항목은 앞에서 배운대로 언더바를 이용하면 변수 할당 없이 건너뛸 수 있다.
var (height, _, name) = getUserInfo()
###################
//튜플 반환값을 정의하는 부분에 변수를 할당해 주었다. 기존에는 타입명만 작성되어 있던 부분이다.이렇게 튜플 인자 타입 앞에 각각의 변수를 붙여 주면 함수의 결과값을 받은 변수에도 이들이 자동으로 바인딩 된다.
func getUserInfo() -> (h:Int,g:Character,n:String) {
//데이터 타입이 String 으로 추론되는 것을 방지하기 위해 타입 어노테이션 선언
let gender : Character = “M”
let height = 180
let name = “꼼꼼한 재은씨”
return (height, gender, name)
}
- 타입얼라이어스
****************************************
* typealias <새로운 타입 이름> = <타입 표현> *
****************************************
typealias infoResult = (Int, Character, String)
func getUserInfo() -> infoResult {
let gender : Character = “M”
let height = 180
let name = “꼼꼼한 재은씨”
return (height, gender, name)
}
//설정 값
getUserInfo().0 // 180
getUserInfo().1 // “M”
getUserInfo().2 // “꼼꼼한 재은씨"
###################
let info = getUserInfo()
info.0 // 180
info.1 // “M”
info.2 // “꼼꼼한 재은씨"
'Swfit' 카테고리의 다른 글
| 10. Swift 일급 객체로서의 함수 (0) | 2017.08.04 |
|---|---|
| 9. Swift 매개변수 (1) | 2017.08.04 |
| 7. Swift 옵셔널 (Optional) (0) | 2017.08.04 |
| 6. Swift 튜플 (Tuple) (0) | 2017.08.04 |
| 5. Swift 집합 (Sets) (0) | 2017.08.04 |
글
7. Swift 옵셔널 (Optional)
Swfit
2017. 8. 4. 11:47
7. Swift 옵셔널 (Optional)
- 옵셔널은 스위프트에서 도입된 새로운 개념 이다.
- 값을 처리하는 과정에서 오류가 발생할 가능성이 있는 값을 옵셔널 타입이라는 객체로 감싼 후 반환하는 개념. -> 옵셔널 래핑(optional wrapping) 이라고도 한다.
let num = Int(“1234”)
// Int 형으로 정상적으로 변환
// num 의 값은 Int 형 1234
###################
let num = Int(“abcd”)
// Int 형으로 변환 하려는 값이 “abcd” 문자열 이므로 변환 이 안됀다.
// num 의 값은 nil 이다.
*******************************
*일반 자료형은 nil 값을 가질 수 없다.*
*******************************
- 옵셔널 타입
var optInt : Int?
// 옵셔널 Int 타입
var optStr : String?
// 옵셔널 String 타입
var optDouble : Double?
// 옵셔널 Double 타입
var optArr : [String]?
// 옵셔널 Array 타입
var opDic : Dictionary<String, String>?
var opDic2 : [String:String]?
// 옵셔널 딕셔너리 타입
var optClass : AnyObject?
// 옵셔널 클래스 타입
- 옵셔널 강제 해제
var optInt : Int? = 3
print(“옵셔널 자체의 값 : \(optInt)”)
print(“!로 강제 해제한 값 : \(optInt!)”)
// 결과 값
옵셔널 자체의 값 : Optinal(3)
!로 강제해제한 값 : 3
###################
Int(“123”) + Int(“123”)
// 연산 불가능
Int(“123”)! + Int(“123”)!
// 연산 가능
// 출력값 = 246
Int(“123”)! + 27
// 연산 가능
// 출력값 = 150
- 옵셔널 바인딩
- 옵셔널 바인딩은 조건문 내에서 일반 상수에 옵셔널 값을 대입하는 방식으로 이루어진다.
- 반드시 조건문에서 사용해야만 하며, 상수에 옵셔널 값을 대입한 결과는 true/false 로 리턴 된다.
//조건문 내에서의 옵셔널 바인딩 처리
var str = “Swift"
if let intFromStr = Int(str) {
print(“값이 변환 되었습니다. 변환된 값은 \(intFromStr) 입니다.”)
}else{
print(“값 변환에 실패하였습니다”)
}
// 출력 : 값 변환에 실패하였습니다.
###################
// 가드문에서 변환된 값이 문자열 이면 값 변환 실패 , 인트형 이면 넘어감
func intStr(str:String) {
guard let intFromstr = Int(str) else {
print(“값 변환에 실패하였습니다.”)
return
}
print(“값이 변환 되었습니다. 변환된 값은 \(intFromStr) 입니다.”)
}
- 옵셔널 딕셔너리 선언
var capital = [“KR” : “Seoul”]
print(capital[“KR”])
print(capital[“KR”]!)
// 출력
Optional(“Seoul”)
Seoul
**********************************************************
* 옵셔널 타입에서 ! 연산자를 사용할 때는 반드시 nil 점검을 해주어야 한다.*
**********************************************************
- 컴파일러에 대한 옵셔널 자동 해제
*******************************
옵셔널 타입의 값을 사용하려면 항상 ! 연산자를 사용하여 옵셔널을 강제해제 하든가, 아니면 옵셔널 바인딩을 통해 일반 자료형으로 바꾸어 주어야 한다. 이렇게 해야 옵셔널 객체로 감싸진 값을 꺼낼수 있다, 하지만 명시적으로 강제 해제를 하지 않아도 컴파일러에서 자동으로 옵셔널을 해제하여 처리하는 경우가 있다.
*******************************
// 강제 해제 옵셔널 타입
let optInt = Int(“123”)
if ((optInt!) == 123) {
print(“opting == 123”)
} else {
print(“optInt != 123”)
}
// 강제 해제 하지 않은 옵셔널 타입
let optInt = Int(“123”)
if (optInt) == 123 {
print(“opting == 123”)
} else {
print(“optInt != 123”)
}
// 결과값 모두 : opting == 123
###################
let tempInt = Int(“123”)
tempInt == 123 // true
tempInt == Optional(123) // true
tempInt! == 123 // true
tempInt! == Optional(123) // true
- 옵셔널의 묵시적 해제
*******************************
옵셔널 타입을 해제하는 방법 중에는 묵시적 해제 라는 개념이 존재한다.
이것은 옵셔널이지만 값을 사용하려고 할 때에는 자동으로 옵셔널이 해제된 값을 제공하기 때문에 굳이 ! 연산자를 사용하여 해제할 필요가 없는 아주 편리한 구문이다.
컴파일러가 알아서 옵셔널을 해제해 준다는 점에서 자동 해제와 유사 하지만 , 컴파일러에 의한 자동 해제가 비교 연산이나 값의 할당 등 일부 구문에 한정되는 것과 달리 묵시적 해제는 옵셔널 변수를 사용하는 모든 경우에 적용할 수 있으며, 옵셔널 변수의 타입을 선언할 때 묵시적 해제를 미리 선언해 주어야 한다는 차이점이 있다.
옵셔널의 묵시적 해제 구문은 일반 옵셔널 타입의 변수 선언 구문과 매우 유사 하다 ? 연산자 대신 ! 연산자만 붙여준다.
*******************************
//명시적 옵셔널 선언
var str : String? = “Swift Optional”
print(str)
// 출력
Optional(“Swift Optional”)
###################
//묵시적 옵셔널 선언
var str : String! = “Swift Optional”
print(str)
// 출력
Swift Optional
###################
var value01 : Int? = 10
value01 + 5 // 오류
var value01 : Int! = 10
value01 + 5 // 15
'Swfit' 카테고리의 다른 글
| 9. Swift 매개변수 (1) | 2017.08.04 |
|---|---|
| 8. Swift 함수(Function) (0) | 2017.08.04 |
| 6. Swift 튜플 (Tuple) (0) | 2017.08.04 |
| 5. Swift 집합 (Sets) (0) | 2017.08.04 |
| 4. Swift 배열 (Array) (0) | 2017.08.04 |
글
6. Swift 튜플 (Tuple)
Swfit
2017. 8. 4. 11:46
6. Swift 튜플 (Tuple)
- 튜플은 스위프트에서 제공하는 특별한 성격의 집단 자료형으로서, 파이썬에서도 사용되는 자료형이다. 튜플은 한가지 타입의 아이템만 저장할 수 있는 배열이나 딕셔너리와는 달리 하나의 튶르에 여러 가지 타입의 아이템을 저장할 수 있지만, 일단 선언되고 나면 상수적 성격을 띠므로 더 이상 값을 추가하거나 삭제하는 등의 변경이 불가능하다. 즉, 타입의 관계없이 다양하게 저장할 수 있지만 오직 최최의 선언된 상태의 아이템만 사용할 수 있고 수정이나 삭제, 추가 등 변경할 수 없는 것이 튜플의 특징이라고 할 수 있다.
예)1.
var color = (“red”,”blue”,”yellow”,”black”)
color.0 = “red”
color.1 = “blue:
color.2 = “yellow”
color3 = “black”
예)2.
var tpl01 : (Int, Int) = (100) , (100)
var tpl02 : (Int,Sting, Int) = (100) , (“ddd”) , (100)
예)3.
let tupleValue:(String , Character, Int , Float, Bool) = (“a” , “b” , 1 , 2.5 , true)
let (a,b,c,d,e) = tupleValue
//a = “a”
//b = “b”
//c = 1
//d = 2.5
//e = true
'Swfit' 카테고리의 다른 글
| 8. Swift 함수(Function) (0) | 2017.08.04 |
|---|---|
| 7. Swift 옵셔널 (Optional) (0) | 2017.08.04 |
| 5. Swift 집합 (Sets) (0) | 2017.08.04 |
| 4. Swift 배열 (Array) (0) | 2017.08.04 |
| 3. Swift 연산자 (0) | 2017.08.04 |
글
5. Swift 집합 (Sets)
Swfit
2017. 8. 4. 11:45
5. Swift 집합 (Sets)
- 집합은 같은 타입의 서로 다른 값을 중복 없이 저장하고자 할 때 사용하는 집단 자료형이다. 배열과 많이 유사 하지만 배열을 사용하기에는 순서가 그다지 중요하지 않은 데이터들이거나 중복 없이 한 번만 저장되어야 하는 데이터들을 다룰 때 배열 대신 사용 할 수 있는 자료형이다.
//배열을 집합으로 변환
var generes = Set<String>( )
if genres.isEmpty {
print(“집합이 비어있다.”)
}else{
print(“집합에는 현재 (genres.count) 개의 아이템이 저장되어 있다”)
// 집합에 데이터 추가
var genres : Set = [“aaa”,”bbb”,”ccc”]
for g in genres {
print(“\(g)”)
}
// aaa
bbb
ccc
// 집합의 데이터 삭제
var genres : Set = [“aaa”,”bbb”,”ccc”]
if let removedItem = genres.remove(“ccc”){
print(“아이템 \(removedItem) 의 삭제가 완료 되었습니다.)
}else {
print(“삭제할 값이 집합에 추가되어 있습니다.”)
}
generes.removeAll() 집합의 모든 값 삭제
// 집합의 연산
var oddDigits : Set = [1,3,5,7,9,] //홀수 집합
let evenDigits : Set = [0,2,4,6,8] //짝수 집합
let primeDigits : Set = [2,3,5,7] //소수 집합
- intersection : 두 집합의 공통된 부분만 선택하여 집합을 만들어 준다.
oddDigits.intersection(evenDigits).sorted( )
// 결과값 [ ] -> 비어있음
// oddDigits 과 evenDigits 의 공통된 부분이 없어 집합이 만들어 지지 않았다.
- symmetricDifference : 두 집합의 공통된 부분만 선택하여 집합을 만들어 준다.
oddDigits.symmetricDifference(primeDigits).sorted( )
// 결과값 [1,2,9 ]
// oddDigits 과 primeDigits 양 쪽의 집합에서 공통된 부분만 빼고 나머지를
선택하여 집합으로 만들어 준다.
- union : 두 집합의 모든 부분을 선택하여 집합을 만들어 준다.
oddDigits.symmetricDifference(evenDigits).sorted( )
// 결과값 [0,1,2,3,4,5,6,7,8,9]
// oddDigits 과 evenDigits 양 쪽의 집합의 모든 부분을 집합으로 만들어 준다.
- subtract : 한쪽 집합의 모든 아이템 에서 다른 집합과 공통된 부분을 뺀 나머지 부분의 집합니다.
oddDigits.subtract(primeDigits)
oddDigits.sorted()
// 결과값 [1,9]
// oddDigits 에서 primeDigits 과의 공통된 부분을 뺀 나머지 집합이다.
'Swfit' 카테고리의 다른 글
| 7. Swift 옵셔널 (Optional) (0) | 2017.08.04 |
|---|---|
| 6. Swift 튜플 (Tuple) (0) | 2017.08.04 |
| 4. Swift 배열 (Array) (0) | 2017.08.04 |
| 3. Swift 연산자 (0) | 2017.08.04 |
| 2. Swift 기본 문법 (0) | 2017.08.04 |
