$ defaults write com.apple.finder AppleShowAllFiles -bool true
$ killall Finder

안보기

$ defaults write com.apple.finder AppleShowAllFiles -bool false
$ killall Finder

const (
    Layout      = "01/02 03:04:05PM '06 -0700" // The reference time, in numerical order.
    ANSIC       = "Mon Jan _2 15:04:05 2006"
    UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
    RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
    RFC822      = "02 Jan 06 15:04 MST"
    RFC822Z     = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
    RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
    RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
    RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
    RFC3339     = "2006-01-02T15:04:05Z07:00"
    RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
    Kitchen     = "3:04PM"
    // Handy time stamps.
    Stamp      = "Jan _2 15:04:05"
    StampMilli = "Jan _2 15:04:05.000"
    StampMicro = "Jan _2 15:04:05.000000"
    StampNano  = "Jan _2 15:04:05.000000000"
)

YYYY-MM-DD

package main

import (
    "fmt"
    "time"
)

const (
    YYYYMMDD = "2006-01-02"
)

func main() {
    now := time.Now().UTC()
    fmt.Println(now.Format(YYYYMMDD))
}
//output: 2022-03-14

DD/MM/YYYY

package main

import (
    "fmt"
    "time"
)

const (
    DDMMYYYY = "02/01/2006"
)

func main() {
    now := time.Now().UTC()
    fmt.Println(now.Format(DDMMYYYY))
}
//output: 14/03/2022

YYYY-MM-DD hh:mm:ss

package main

import (
    "fmt"
    "time"
)

const (
    DDMMYYYYhhmmss = "2006-01-02 15:04:05"
)

func main() {
    now := time.Now().UTC()
    fmt.Println(now.Format(DDMMYYYYhhmmss))
}
//output: 2022-03-14 05:41:33

출처: https://gosamples.dev/date-format-yyyy-mm-dd/

base64:

import (
    "bytes"
    "crypto/aes"
    "crypto/cipher"
    "encoding/base64"
    "fmt"
)

func AESEncrypt(src string, key []byte, iv string) string {
    block, err := aes.NewCipher(key)
    if err != nil {
        fmt.Println("key error1", err)
    }
    if src == "" {
        fmt.Println("plain content empty")
    }
    ecb := cipher.NewCBCEncrypter(block, []byte(iv))
    content := []byte(src)
    content = PKCS5Padding(content, block.BlockSize())
    crypted := make([]byte, len(content))
    ecb.CryptBlocks(crypted, content)

    return base64.StdEncoding.EncodeToString(crypted)
}

func AESDecrypt(cryptedStr string, key []byte, iv string) []byte {
    encryptedData, _ := base64.StdEncoding.DecodeString(cryptedStr)
    block, err := aes.NewCipher(key)
    if err != nil {
        fmt.Println("key error1", err)
    }
    if len(encryptedData) == 0 {
        fmt.Println("plain content empty")
    }
    ecb := cipher.NewCBCDecrypter(block, []byte(iv))
    decrypted := make([]byte, len(encryptedData))
    ecb.CryptBlocks(decrypted, encryptedData)

    return PKCS5Trimming(decrypted)
}

func PKCS5Padding(ciphertext []byte, blockSize int) []byte {
    padding := blockSize - len(ciphertext)%blockSize
    padtext := bytes.Repeat([]byte{byte(padding)}, padding)
    return append(ciphertext, padtext...)
}

func PKCS5Trimming(encrypt []byte) []byte {
    padding := encrypt[len(encrypt)-1]
    return encrypt[:len(encrypt)-int(padding)]
}

hex:

func Ase256Encode(plaintext string, key string, iv string, blockSize int) string {
    bKey := []byte(key)
    bIV := []byte(iv)
    bPlaintext := PKCS5Padding([]byte(plaintext), blockSize, len(plaintext))
    block, err := aes.NewCipher(bKey)
    if err != nil {
        panic(err)
    }
    ciphertext := make([]byte, len(bPlaintext))
    mode := cipher.NewCBCEncrypter(block, bIV)
    mode.CryptBlocks(ciphertext, bPlaintext)
    return hex.EncodeToString(ciphertext)
}

func Ase256Decode(cipherText string, encKey string, iv string) (decryptedString string) {
    bKey := []byte(encKey)
    bIV := []byte(iv)
    cipherTextDecoded, err := hex.DecodeString(cipherText)
    if err != nil {
        panic(err)
    }

    block, err := aes.NewCipher(bKey)
    if err != nil {
        panic(err)
    }

    mode := cipher.NewCBCDecrypter(block, bIV)
    mode.CryptBlocks([]byte(cipherTextDecoded), []byte(cipherTextDecoded))
    return string(cipherTextDecoded)
}

func PKCS5Padding(ciphertext []byte, blockSize int, after int) []byte {
    padding := (blockSize - len(ciphertext)%blockSize)
    padtext := bytes.Repeat([]byte{byte(padding)}, padding)
    return append(ciphertext, padtext...)
}

PKCS5Padding:

fun encryptCBC(strToEncrypt: String, key: String, iv: String): String {

    try {

        val ivParameterSpec = IvParameterSpec(iv.toByteArray())
        val secretKey = SecretKeySpec(key.toByteArray(), "AES")

        val cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivParameterSpec)

        val crypted = cipher.doFinal(strToEncrypt.toByteArray())
        val encodedByte = Base64.encode(crypted, Base64.DEFAULT)

        return String(encodedByte)

    } catch (e: Exception) {
        Log.e("Exception", "Exception : ${e.message}")
    }
    return ""
}

fun decryptCBC(strToDecrypt: String, key: String, iv: String): String {

    val ivParameterSpec = IvParameterSpec(iv.toByteArray())
    val secretKey = SecretKeySpec(key.toByteArray(), "AES")

    val cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
    cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParameterSpec)

    val decodedByte = Base64.decode(strToDecrypt, Base64.DEFAULT)
    val byteResult = cipher.doFinal(decodedByte)

    return String(byteResult)
}

PKCS7Padding:

object AESEncyption {

    const val secretKey = "tK5UTui+DPh8lIlBxya5XVsmeDCoUl6vHhdIESMB6sQ="
    const val salt = "QWlGNHNhMTJTQWZ2bGhpV3U=" // base64 decode => AiF4sa12SAfvlhiWu
    const val iv = "bVQzNFNhRkQ1Njc4UUFaWA==" // base64 decode => mT34SaFD5678QAZX

    fun encrypt(strToEncrypt: String) : String?
    {
        try
        {
            val ivParameterSpec = IvParameterSpec(Base64.decode(iv, Base64.DEFAULT))

            val factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1")
            val spec =  PBEKeySpec(secretKey.toCharArray(), Base64.decode(salt, Base64.DEFAULT), 10000, 256)
            val tmp = factory.generateSecret(spec)
            val secretKey =  SecretKeySpec(tmp.encoded, "AES")

            val cipher = Cipher.getInstance("AES/CBC/PKCS7Padding")
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivParameterSpec)
            return Base64.encodeToString(cipher.doFinal(strToEncrypt.toByteArray(Charsets.UTF_8)), Base64.DEFAULT)
        }
        catch (e: Exception)
        {
            println("Error while encrypting: $e")
        }
        return null
    }

    fun decrypt(strToDecrypt : String) : String? {
        try
        {
            val ivParameterSpec =  IvParameterSpec(Base64.decode(iv, Base64.DEFAULT))

            val factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1")
            val spec =  PBEKeySpec(secretKey.toCharArray(), Base64.decode(salt, Base64.DEFAULT), 10000, 256)
            val tmp = factory.generateSecret(spec);
            val secretKey =  SecretKeySpec(tmp.encoded, "AES")

            val cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");
            cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParameterSpec);
            return  String(cipher.doFinal(Base64.decode(strToDecrypt, Base64.DEFAULT)))
        }
        catch (e : Exception) {
            println("Error while decrypting: $e");
        }
        return null
    }
}

gcm 사용

fun encrypt(password: String): String {
    val secretKeySpec = SecretKeySpec(password.toByteArray(), "AES")
    val iv = ByteArray(16)
    val charArray = password.toCharArray()
    for (i in 0 until charArray.size){
        iv[i] = charArray[i].toByte()
    }
    val ivParameterSpec = IvParameterSpec(iv)

    val cipher = Cipher.getInstance("AES/GCM/NoPadding")
    cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec)

    val encryptedValue = cipher.doFinal(this.toByteArray())
    return Base64.encodeToString(encryptedValue, Base64.DEFAULT)
}

fun decrypt(password: String): String {
    val secretKeySpec = SecretKeySpec(password.toByteArray(), "AES")
    val iv = ByteArray(16)
    val charArray = password.toCharArray()
    for (i in 0 until charArray.size){
        iv[i] = charArray[i].toByte()
    }
    val ivParameterSpec = IvParameterSpec(iv)

    val cipher = Cipher.getInstance("AES/GCM/NoPadding")
    cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec)

    val decryptedByteValue = cipher.doFinal(Base64.decode(this, Base64.DEFAULT))
    return String(decryptedByteValue)
}

Intel Mac DB Port 3307 설정시

mysql 5.6 docker image 로 내려받기

$ docker pull mysql:5.6

mysql 서비스 시작

$ docker run -p 3307:3306 --name [컨테이너명] -e MYSQL_ROOT_PASSWORD=[비밀번호] -d mysql:5.6

mariadb 10.5 서비스 시작

$ docker run -p 3307:3306 --name [컨테이너명] -e MYSQL_ROOT_PASSWORD=[비밀번호] -d mariadb:10.5

M1 Mac

mysql 5.7 docker image 로 내려받기

$ docker pull --platform linux/amd64 mysql:5.7

mysql 서비스 시작

$ docker run --platform linux/amd64 -p 3306:3306 --name [컨테이너명] -e MYSQL_ROOT_PASSWORD=[비밀번호] -d mysql:5.7

mysql 접속 및 설정

docker 컨테이너 터미널 접속(Desktop 으로도 터미널접속 가능)

$ docker exec -it [컨테이너명] /bin/bash

mysql 접속

$ mysql -u root -p
$ [비밀번호] //위에서 설정한 비밀번호

mysql 비밀번호 변경

$ brew install mysql@5.7

서비스 시작:

$ brew services start mysql@5.7

brew install xcodegen

project.yml 파일 편집:

name: ProjectName
targets:
  ProjectName:
    type: application
    platform: iOS
    deploymentTarget: "15.0"
    sources: [ProjectName]
    settings:
      base:
        INFOPLIST_FILE: ProjectName/Info.plist
        PRODUCT_BUNDLE_IDENTIFIER: com.example.ProjectName

터미널 명령어 실행:

xcodegen generate

출처: https://github.com/yonaskolb/XcodeGen

priceAmountMicros to float 으로 변환후 소수점 3번째짜리에서 반올림

java:

public float getPrice(SkuDetails item) {
    double price = item.getPriceAmountMicros() / 1000000.0;
    return (float) (Math.round(price*1e2)/1e2);
}

kotlin:

fun getPrice(item: SkuDetails) : Float {
    val price = item.priceAmountMicros / 1000000.0
    return (round(price*100)/100).toFloat()
}

result, _ := iconv.ConvertString(string(output), "euc-kr", "utf-8")

https://github.com/djimenez/iconv-go

윈도우 사용자: 윈도우는 gcc 활성화를 위해서 MinGW를 설치해야 한다.(키보드 관련 go 라이브러리도 마찬가지) 인스톨 파일이 작동되지 않는다면 압축파일 받아서 ProgramFiles 에 압축해제해서 떨궈놓고 환경변수(mingw64/bin)만 셋팅하면 된다.

$ redis-cli

set get del

[127.0.0.1:6379> set key value
[127.0.0.1:6379> get key
[127.0.0.1:6379> del key

$ brew install redis

설치 확인

$ brew list

foreground 실행 및 중지

$ redis-server

background 실행 및 중지

$ brew services start redis
$ brew services info redis
$ brew services stop redis

서비스 확인

$ brew services list

public enum LanguageCode : Int{
    case ko
    case en
    case ja
    case zhcn
    case zhtw
    case th
    case vi
    case es
    case pt
    case fr
    case de
    case ru

    var description: String {
        return String(describing: self)
    }
}

print(languageCode.rawValue) //0
print(languageCode.description) //ko

string to enum:

public enum LoginType: String {
    case google="GOOGLE"
    case facebook="FACEBOOK"
    case apple="APPLE"
    case guest="GUEST"
}

print(LoginType.google.rawValue) //GOOGLE

출처 https://stackoverflow.com/questions/28461133/swift-enum-both-a-string-and-an-int https://stackoverflow.com/questions/24701075/swift-convert-enum-value-to-string

struct Login: Codable {
    let code: UInt
    let msg: String
    let data: LoginInfo
    enum CodingKeys: String, CodingKey {
        case code = "code"
        case msg = "msg"
        case data = "data"
    }
}

struct LoginInfo: Codable {
    let userID: String
    let username: String
    enum CodingKeys: String, CodingKey {
        case userID = "userID"
        case username = "username"
    }
}

long long milliseconds = (long long)([[NSDate date] timeIntervalSince1970] * 1000.0);

swift:

// ex1)
let currentDate = NSNumber(value:Int64(Date().timeIntervalSince1970 * 1000))

// ex2)
extension Date {

    func toMillis() -> NSNumber {
        return NSNumber(value:Int64(timeIntervalSince1970 * 1000))
    }

    var timestamp: Int64 {
        Int64(timeIntervalSince1970 * 1000)
    }
}

공식사이트 를 통해 설치합니다.(m1 이든 intel 이든 설치명령어는 같습니다.)

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

환경변수

m1 은 설치된 바이너리 디렉토리가 달라서 환경변수 설정을 해줘야 합니다. (intel은 자동설정됨)

export HOME_BREW="/opt/homebrew/bin"
export PATH=$PATH:$HOME_BREW

공식사이트 를 통해 설치합니다.

환경변수

윈도우든 맥이든 환경변수를 설정해야 합니다.

• GOROOT : /usr/local/go (설치시 자동 설정됨)
• GOPATH : workspace 에 해당하므로 임의로 정하면 됩니다.
• GOBIN : $GOPATH/bin

특히 GOROOT, GOPATH 가 제대로 설정되있어야 mod 명령어가 잘 작동됩니다.

환경변수 설정은 각자 알아서 본인취향대로 하면 됩니다.

mod 사용법

• go mod init

  기본적으로 mod 파일을 생성해주고 vendor 폴더가 존재한다면 vendor.json 파일을 읽고 mod 파일을 생성하여 내부 프로젝트에서 사용되고 있는 의존성 소스에 대해 내려받고 관리해준다.

• go mod vendor

  vendor 디렉토리를 생성해줍니다

• go mod tidy

  프로젝트 내부 의존성을 토대로 mod 파일 업데이트

참고

• Go Modules 살펴보기

$ mysql

mysql db 접근

[MariaDB [(none)]> use mysql

root 비번 설정

// mysql 5.6 이하
[mysql]> set password for 'root'@'localhost' = PASSWORD('1234');
// mysql 5.7 이상
[mysql]> set authentication_string=password('new password') where user = 'root';
// mysql 8.x 이상
[mysql]> alter user 'root'@'localhost' identified with mysql_native_password by 'new password';

// mariadb 10.4 이상
[MariaDB [mysql]> set password=password('1234');
[MariaDB [mysql]> flush privileges;

root 로그인

mysql -uroot -p1234

$ vi /usr/local/etc/my.cnf

저장후 서비스 재시작

$ brew services restart mariadb

서비스 확인

$ brew services list

port 변경확인

$ sudo lsof -i :8000

home brew 를 이용해 설치합니다.

$ brew update
$ brew install carthage

Cartfile 생성

.xcodeproj 또는 .xcworkspace가 있는 동일한 디렉토리에 Cartfile을 만듭니다.

$ touch Cartfile

Cartfile 편집

Cartfile에 원하는 종속성을 나열합니다. 예를 들면 다음과 같습니다.

github "Alamofire/Alamofire" ~> 5.5

실행

$ carthage update --use-xcframeworks

빌드된 Framework 적용

Carthage/Build에서 빌드된 .xcframework 번들을 애플리케이션 Xcode 프로젝트의 "Frameworks and Libraries" 섹션으로 드래그합니다.

Application에 Carthage를 사용하는 경우 "Embed & Sign"을 선택하고, 그렇지 않으면 "Do Not Embed"를 선택하십시오.

출처: https://www.darrencoxall.com/golang/executing-commands-in-go