01. .at()

"문자열".at(위치값)

  • 지정한 숫자(index)를 받아, 문자열에서 해당되는 인덱스의 요소를 반환합니다.
  • 대소문자를 구별합니다.
  • 문자열의 길이보다 큰 인덱스를 지정하면 undefined를 반환합니다.
  • 음수인 경우 문자열의 오른쪽에서부터 인덱스를 샙니다.
{
    "javascript reference".at()       //j
    "javascript reference".at(0)      //j
    "javascript reference".at(1)      //a
    "javascript reference".at(2)      //v
    "javascript reference".at(3)      //a
    "javascript reference".at(4)      //s
    "javascript reference".at(5)      //c
    "javascript reference".at(-1)     //e
    "javascript reference".at(-2)     //c
    "javascript reference".at(-3)     //n
    "javascript reference".at(-4)     //e
    "javascript reference".at(-5)     //r
    "javascript reference".at(100)    // undefined
}

06 .includes()

"문자열".includes(값)

  • includes() 함수는 JavaScript에서 배열이나 문자열에서 특정 요소나 문자열이 존재하는지 확인할 때 사용합니다.
  • 이 함수는 요소나 문자열이 존재하면 true
  • 존재하지 않으면 false를 반환합니다.
{
        const sentence = "Hello, world!";
        console.log(sentence.includes("world"));  // true
        console.log(sentence.includes("bye"));    // false                                        
}

07 .indexof()

"문자열".indexof(옵션)

  • indexof() 함수는 JavaScript의 JavaScript의 문자열과 배열에서 사용되는 메서드로.
  • 특정 요소 또는 문자가 처음 나타나는 위치를 반환합니다.
{
        const sentence = "Hello, welcome to the world of JavaScript!";
        const index1 = sentence.indexOf('e');
        console.log(index1); // 출력: 1 ('e'가 인덱스 1 위치에 있음)     
        
        // 문자열에서 부분 문자열 "world"의 첫 번째 등장 위치 찾기
        const text = "The quick brown fox jumps over the lazy dog.";
        const index2 = text.indexOf("fox");
        console.log(index2); // 출력: 16 ('fox' 부분 문자열이 인덱스 16 위치에 있음)

        // 배열에서 숫자 3의 첫 번째 등장 위치 찾기
        const numbers = [1, 2, 3, 4, 5, 3, 2, 1];
        const index3 = numbers.indexOf(3);
        console.log(index3); // 출력: 2 (숫자 3이 인덱스 2 위치에 있음)
}

10 .match()

"문자열".match(정규식)

  • javaScript: String.prototype.match는 문자열에서 정규식 패턴을 찾습니다.
  • Python: re.match는 문자열의 시작 부분에서 정규식 패턴을 찾습니다.
  • ust, Swift, Kotlin: 패턴 매칭을 위한 키워드로 다양한 조건에 따라 표현식을 분기합니다
{
        fun main() {
                val number = 2
                
                when (number) {
                        1 -> println("One")
                        2 -> println("Two")
                        3 -> println("Three")
                        else -> println("Other")
                }
                }
                // 출력: Two

                let number = 3

        switch number {
        case 1:
            print("One")
        case 2:
            print("Two")
        case 3:
            print("Three")
        default:
            print("Other")
        }
        // 출력: Three

}

16 .replace()

"문자열".replace(찾을 패턴, 대체할 문자열)

  • JavaScript: `String.prototype.replace`는 문자열 내 특정 패턴을 다른 문자열로 교체합니다.
    • 예시: `"Hello, world!".replace("world", "everyone")` → `"Hello, everyone!"`
    • 정규식 사용: `"Hello, world!".replace(/world/i, "everyone")` → `"Hello, everyone!"`
  • Python: `str.replace`는 문자열 내 모든 일치하는 부분을 다른 문자열로 교체합니다.
    • 예시: `"Hello, world!".replace("world", "everyone")` → `"Hello, everyone!"`
    • 정규식 사용: `re.sub(r'world', 'everyone', "Hello, world!")` → `"Hello, everyone!"`
{
        //JavaScript: String.prototype.replace
        // 단순 문자열 대체
        console.log("Hello, world!".replace("world", "everyone")); // "Hello, everyone!"
        
        // 정규식 사용
        console.log("Hello, World!".replace(/world/i, "everyone")); // "Hello, everyone!"

        //Python: str.replace
        # 단순 문자열 대체
        text = "Hello, world!"
        print(text.replace("world", "everyone"))  # "Hello, everyone!"

        # 정규식 사용
        import re
        text = "Hello, world!"
        print(re.sub(r'world', 'everyone', text))  # "Hello, everyone!"
}

18 .search()

"문자열".search(정규식)

  • JavaScript: `String.prototype.search`는 문자열에서 정규식 패턴을 찾아 인덱스를 반환합니다.
    • 예시: `"Hello, world!".search(/world/)` → `7`
    • 찾는 패턴이 없을 경우 `-1`을 반환합니다.
  • Python: `re.search`는 문자열에서 정규식 패턴과 일치하는 첫 부분을 반환합니다.
    • 예시: `re.search(r'world', "Hello, world!")` → ` `
    • 찾는 패턴이 없을 경우 `None`을 반환합니다.
{
        //JavaScript: String.prototype.search
        // 패턴 일치
        console.log("Hello, world!".search(/world/)); // 7
        
        // 패턴 불일치
        console.log("Hello, world!".search(/everyone/)); // -1

        //Python: re.search
        import re

        # 패턴 일치
        match = re.search(r'world', "Hello, world!")
        if match:
            print(match) # re.Match object; span=(7, 12), match='world'
        
        # 패턴 불일치
        match = re.search(r'everyone', "Hello, world!")
        if not match:
            print("Pattern not found")  # Pattern not found
        
}

19. .slice()

"배열 또는 문자열".slice(시작 인덱스, 종료 인덱스)

  • JavaScript: `Array.prototype.slice`와 `String.prototype.slice`는 배열 또는 문자열의 일부를 추출합니다.
    • 예시: `['a', 'b', 'c', 'd'].slice(1, 3)` → `['b', 'c']`
    • 예시: `"Hello, world!".slice(7, 12)` → `"world"`
  • Python: `list[start:end]`, `str[start:end]`는 리스트 또는 문자열의 일부를 슬라이스합니다.
    • 예시: `['a', 'b', 'c', 'd'][1:3]` → `['b', 'c']`
    • 예시: `"Hello, world!"[7:12]` → `"world"`
{
        //JavaScript: Array.prototype.slice와 String.prototype.slice
        // 배열
        const letters = ['a', 'b', 'c', 'd'];
        console.log(letters.slice(1, 3)); // ['b', 'c']

        // 문자열
        const text = "Hello, world!";
        console.log(text.slice(7, 12)); // "world"

        //python: 리스트 및 문자열 슬라이싱
        # 리스트
        letters = ['a', 'b', 'c', 'd']
        print(letters[1:3])  # ['b', 'c']
        
        # 문자열
        text = "Hello, world!"
        print(text[7:12])  # "world"
        
}

20. .substring()

"문자열".substring(시작 인덱스, 종료 인덱스)

  • JavaScript: `String.prototype.substring`은 문자열의 일부를 추출합니다.
    • 예시: `"Hello, world!".substring(7, 12)` → `"world"`
    • 종료 인덱스는 포함되지 않습니다.
    • 음수 인덱스는 자동으로 `0`으로 변환됩니다.
    • 인덱스 순서는 시작과 종료 인덱스에 상관없이 자동 정렬됩니다.
  • Python: `str[start:end]`는 문자열의 일부를 슬라이스합니다.
    • 예시: `"Hello, world!"[7:12]` → `"world"`
    • 음수 인덱스를 지원하여 문자열의 끝에서부터 슬라이스 가능합니다.
    • 종료 인덱스는 포함되지 않습니다.
{
        //JavaScript: String.prototype.substring
        const text = "Hello, world!";

        // 시작과 종료 인덱스 순서 상관 없이 추출
        console.log(text.substring(7, 12)); // "world"
        console.log(text.substring(12, 7)); // "world"
        
        // 음수 인덱스는 0으로 처리
        console.log(text.substring(-3, 5)); // "Hello"
        

        Python: 문자열 슬라이싱 (str[start:end])
        text = "Hello, world!"

        # 시작과 종료 인덱스에 따라 슬라이싱
        print(text[7:12])  # "world"
        
        # 음수 인덱스 사용
        print(text[-6:-1])  # "world"        
        
}

22. .split()

"문자열".split(구분자, 최대 분할 횟수)

  • JavaScript: `String.prototype.split`은 문자열을 구분자를 기준으로 나누어 배열을 생성합니다.
    • 예시: `"Hello, world!".split(", ")` → `["Hello", "world!"]`
    • 예시: `"a,b,c,d".split(",", 2)` → `["a", "b"]`
    • 구분자가 없을 경우 전체 문자열이 하나의 요소로 반환됩니다.
  • Python: `str.split`은 문자열을 구분자로 나누어 리스트를 생성합니다.
    • 예시: `"Hello, world!".split(", ")` → `["Hello", "world!"]`
    • 예시: `"a,b,c,d".split(",", 2)` → `["a", "b"]`
    • 구분자가 없을 경우 공백을 기준으로 분할됩니다.
{
        //JavaScript: String.prototype.split
        // 구분자로 나누기
        console.log("Hello, world!".split(", ")); // ["Hello", "world!"]
        
        // 최대 분할 횟수 지정
        console.log("a,b,c,d".split(",", 2)); // ["a", "b"]
        
        // 구분자 없이 분할 시 전체 문자열이 하나의 요소로 반환
        console.log("Hello".split()); // ["Hello"]
        

        Python: str.split
        # 구분자로 나누기
        print("Hello, world!".split(", "))  # ["Hello", "world!"]
        
        # 최대 분할 횟수 지정
        print("a,b,c,d".split(",", 2))  # ["a", "b"]
        
        # 구분자 없이 분할 시 공백을 기준으로 분할
        print("Hello world!".split())  # ["Hello", "world!"]
               
        
}

30. .trim()

"문자열".trim()

  • JavaScript: `String.prototype.trim`은 문자열의 양 끝에 있는 공백을 제거합니다.
    • 예시: `" Hello, world! ".trim()` → `"Hello, world!"`
    • 중간의 공백은 그대로 유지합니다.
  • Python: `str.strip`은 문자열의 양 끝에 있는 공백을 제거합니다.
    • 예시: `" Hello, world! ".strip()` → `"Hello, world!"`
    • `lstrip()`과 `rstrip()`은 각각 좌측 또는 우측 공백만 제거합니다.
{

        //JavaScript: String.prototype.trim
        const text = "   Hello, world!   ";
        console.log(text.trim()); // "Hello, world!"
        

        //Python: str.strip, str.lstrip, str.rstrip
        text = "   Hello, world!   "
        print(text.strip())  # "Hello, world!"
        print(text.lstrip())  # "Hello, world!   "
        print(text.rstrip())  # "   Hello, world!"
}