Swift 문법 정리(-ing)

Apple🍎/Swift 2024. 4. 23. 18:57

숫자

Float, Double

Float은 소수점 이하 6자리만 표현 가능, Double은 15자리까지 가능하다.

var FloatValue: Float = 1.2345678910
var DoubleValue: Double = 1.2345678910
 
print("FloatValue는 : \(FloatValue), Double은 : \(DoubleValue)")
//FloatVlaue는 : 1.2345679, Double은 : 1.234567891
//FloatVlaue는 9에서 짤리지만, Double은 모든 소수점을 다 보여준다.
 
FloatValue = 123.456
 
print(FloatValue)

제곱근(sqrt), 제곱(pow)

import Foundation 필요

sqrt(double형) -> return Double

Float, Double -> Int 반올림, 내림, 올림

let pi = 3.14
print(Int(pi))

// float -> Int
let floatNumber: Float = 3.14
let ftoi = lroundf(floatNumber)

let doubleNumber: Double = 3.43
let dtoi = lroundl(doubleNumber)

진법 변환

정수를 이진변환 String(number, radix: 2)

let number = 42
let binaryString = String(number, radix: 2)
print(binaryString) // 출력: "101010"

이진법을 10진수 정수로 변환 Int(binaryString, radix: 2)

let binaryString = "101010"
if let number = Int(binaryString, radix: 2) {
    print(number) // 출력: 42
} else {
    print("Invalid binary string")
}

정수 -> 이진변환 후 1의 개수 알기 (nonzeroBitCount)

let num = 4
n.nonzeroBitCount // 1

String(num, radix:2).filter { $0 == "1" }.count
보다 훨씬 성능이 빠름

문자열

문자열 대소문자 바꾸기

s = "pPoooyY"
s = s.lowercased() // ppoooyy
s = s.uppercased() // PPOOOYY

문자열 슬라이싱 (SubString)

Swift에서의 String의 인덱스에 Int로 받지 않고, String.Index를 사용한다.

String.Index : 스위프트에서 문자열의 인덱스를 표현하기 위해 사용하는 특수한 타입

앞, 뒤에서부터 글자 가져오기

1) s.prefix(n) // 앞에서부터 n글자 가져오기
2) s[s.startIndex] // startIndex 활용
3) let idx = String.Index(encodedOffset: 0) //0번째 인덱스를 나타내는 인덱스 생성
	s[idx]
    
4) 뒤에서부터 가져오기
subfix(n) : 뒤에서부터 n글자 가져오기
let lo = hello.suffix(2)

문자열의 두 번째 글자 구하기

두 번째 글자를 나타내는 인덱스를 먼저 생성한 뒤, 그 인덱스를 활용해 두 번쨰 글자를 찾는다.

let secondIndex = hello.index(after: hello.startIndex)
let second = hello[secondIndex]

문자열의 n번째 이후 모든 글자

String.index(시작 위치, offsetBy: Int(시작위치로부터 떨어진 위치))

let s = "12:00:00AM"
let timeIndex = s.index(s.startIndex, offsetBy: 7)
let timeStr = String(s[...timeIndex]) // 12:00:00
let ampmIndex = s.index(s.endIndex, offsetBy: -2)
let ampmStr = String(s[ampmIndex...]) // AM

// 또는 아래와 같이 구할 수도 있다
let timeStr2 = s.prefix(8) // 앞에서부터 8개 글자 12:00:00
let ampmStr2 = s.suffix(2) // 뒤부터 2글자 AM

3 ~ 10번까지의 문자열 가져오기

if let input = readLine() {
    let startIndex = input.index(input.startIndex, offsetBy: 2)
    let endIndex = input.index(input.startIndex, offsetBy :9)
    print(input[startIndex...endIndex])
}

문자열의 맨 마지막 글자 구하기

index를 사용해 구하는 방법: index(before: ) & endIndex
suffix로 item 1개를 가져오는 방법: suffix(1)

// hello[hello.endIndex] -> 에러.

let endIndex = hello.index(before: hello.endIndex)
let last = hello[endIndex]

맨 뒤부터 움직이는 offset의 경우 음수로 넣는다. 
let endIndex = hello.index(hello.endIndex, offsetBy: -1)

let item = hello.suffix(1)

문자열에서 특정 문자의 인덱스 구하기

func firstIndex(of: Character) -> String.Index? 또는

func lastIndex(of: Character) -> String.Index? 를 활용한다.

예를 들어 o라는 문자의 인덱스를 구하려면 아래와 같이 사용한다.

let oIndex = hello.index(of: "o")

❗️String.Index 을 구하기 위해 사용한 위의 메서드들은 사실 Substring에서 제공하는 메서드들이다!

문자열 잘라내기

스위프트의 substring = 부분문자열 을 의미한다.

부분문자열은 String.Index를 활용해 범위(range)를 먼저 만들고, 그 범위를 이용해 구한다.

예를 들어 var hello = "hello" 에서 맨 앞, 맨 뒤 글자를 제외한 ell만 구해 보자.

let rangeStartIndex = hello.index(after: hello.startIndex)
let rangeEndIndex = hello.index(hello.index, offsetBy: -2)
let ellSubstring = hello[rangeStartIndex...rangeEndIndex] // Substring 타입의 "ell" 생성

// 아래 코드는 위의 코드와 같은 역할이다.

let rangeStartIndex = hello.index(after: hello.startIndex)
let rangeEndIndex = hello.index(before: hello.endIndex)
let ellSubstring = hello[rangeStartIndex..<rangeEndIndex] // ..< 을 사용함에 주의

인덱스의 범위를 이용해 얻은 부분문자열은 String이 아닌 Substring이라는 별도의 타입이므로, String으로 캐스팅해 주어야 한다.

let ellString = String(ellSubstring)

Ascii 변환

Int ->String : String(UnicodeScalar(65)!) // "A"
Stirng-> Int: Int(UnicodeScalar("A").valule) // 65

문자열 숫자/문자인지 확인

Character 타입의 확장이다.
- isLetter: 문자가 알파벳 문자(A-Z, a-z)인지 확인
- isNumber: 문자가 숫자(0-9)인지 확인
- isSymbol: 문자가 기호인지 확인
- isPunctuation: 문자가 문장 부호인지 확인
- isWhitespace: 문자가 공백 문자인지 확인

character.isNumber
letter.isLetter

문자열 교체(replaceOccurences(of: with:)

 var s = s.replacingOccurrences(of: "0", with: "")
 // 1101 -> 111

배열

배열 선언

// 빈 배열
let arrInt: Array<Int> = []
let arrInt2 = Array<Int>()

// 초기화 한 배열
let arrBool = [Bool](repeating: false, count: 10) // [false 10개]
let zeroArray1 = [Int](repeating: 0, count: 10) // [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
let zeroArray2 = Array(repeating: 0, count: 10) // [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

var a = [Int](-5...5) // [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]

배열 기본 함수(추가, 삭제, isEmpty, popLast() )

// 원소 추가
arr.append(item)

// 원소 삭제
arr.remove(at: idx)

arr.isEmpty

arr.popLast() // 마지막 원소 빼면서, 원소 알려줌 -> O(1)

배열의 총 개수 세기 -> count, capacity

var names = ["Gregory", "Perry", "Nadal"]
print(names.count)  

var employees = [String]()
print(employees.count)

배열의 특정 원소 찾기 -> filter, components, split

components, split 둘다 쪼개는 것
- components - separatedBy, return 값: Array<String>
- split - separator, return 값: Array<Substring>

array.filter { $0 % 2 == 0 }

/* components */
import Foundation
var str = "안녕하세요 split과 components에 대해 알아보아요"
str.components(separatedBy: " ")

//결과: ["안녕하세요", "split과", "components에", "대해", "알아보아요"]

/* split */
var str = "안녕하세요 split과 components에 대해 알아보아요"
str.split(separator: " ")

//결과: ["안녕하세요", "split과", "components에", "대해", "알아보아요"]

배열 최소, 최대값 구하기(min, max)

var arr = [60,70,80,90,100]
arr.min() //Optional(60)
arr.max() //Optional(100)

배열 전체 합 -> reduce

let numberArray = [1,2,3,4,5,6,7,8,9,10]
let sum = numberArray.reduce(0, { (first: Int, second: Int) -> Int in
    return first + second
})
print(sum)
// 55

# 매개변수, 반환 타입, 반환 키워드(return) 생략한 후행 클로저
let numberArray = [1,2,3,4,5,6,7,8,9,10]
let sum = numberArray.reduce(0) { $0 + $1 }
print(sum)
// 55

Int -> list로 바꾸는 경우

1) compactMap

String으로 정수를 문자열로 변환. compactMap으로 문자열 -> 문자 배열로 변환.

$0은 문자(char)이므로 문자열인 String으로 바꿔준 뒤에, Int형으로 변환해야한다. # swift에선 char -> Int는 지원 X

let number = 1234
let array = String(number).compactMap { Int(String($0)) }
print(array) // 결과: [1, 2, 3, 4]

2) compactMap, wholeNumberValue

wholeNumberValue: 문자(char)가 의미하는 숫자값을 반환하는 것

let n = 1234
var temp = String(n).compactMap { $0.wholeNumberValue }
print(temp) // 결과: [1, 2, 3, 4]

- 문자열을 반대로 -> reversed(), collection을 반대로 -> reverse()

* reversed() -> O(1), reverse() -> O(N)

var temp = [1, 2, 3, 4]
print(Array(temp.reversed()))
// Array를 씌워줘야 [4, 3, 2, 1] 이 나온다

배열을 이어서 출력하기 (joined(separator: "")

let cast = ["Vivien", "Marlon", "Kim", "Karl"]
let list = cast.joined(separator: ", ")
print(list)
// Prints "Vivien, Marlon, Kim, Karl"

정수의 각 자리를 정렬한 후 새로운 정수를 리턴하기

정수를 리스트로 변환 -> 정렬 -> 다시 하나의 정수로 만들기

func solution(_ n: Int) -> Int {
    // 정수를 문자열로 변환하여 각 자릿수를 문자 배열로 만듭니다.
    let digits = String(n).compactMap { Int(String($0)) }
    
    // 자릿수를 내림차순으로 정렬합니다.
    let sortedDigits = digits.sorted(by: >)
    
    // 내림차순으로 정렬된 자릿수 배열을 다시 정수로 변환합니다.
    let sortedNumber = Int(sortedDigits.map { String($0) }.joined()) ?? 0
    
    return sortedNumber
}

// 예시: 118372를 호출하면 873211을 반환합니다.
print(solution(118372)) // Output: 873211

사전(Dictionary)

Key값을 tuple로 넣는 경우

struct Pair: Hashable {
    let first: Int
    let second: Int
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(first)
        hasher.combine(second)
    }
    
    static func ==(lhs: Pair, rhs: Pair) -> Bool {
        return lhs.first == rhs.first && lhs.second == rhs.second
    }
}

Dictionary 선언 및 초기화

var myDictionary: [ Pair : String ] = [ : ]

myDictionary[Pair(first: 1, second: 1)] = "One-One" 
myDictionary[Pair(first: 2, second: 3)] = "Two-Three" 
myDictionary[Pair(first: 4, second: 5)] = "Four-Five"

* 하지만 Swift 4.2 이상부턴,

// 키값 튜플 만들기
struct PopKey: Hashable {
    let x: Int
    let y: Int
}

이렇게 작성해도, 위의 hash, 비교함수를 자동으로 생성한다.

저작자표시

ABOUT ME

정신차려 하프물범 정신차려 하프물범

숫자