{"id":479194,"date":"2023-08-09T10:31:59","date_gmt":"2023-08-09T10:31:59","guid":{"rendered":""},"modified":"2023-09-05T11:18:22","modified_gmt":"2023-09-05T11:18:22","slug":"subtyping","status":"publish","type":"wiki","link":"https:\/\/oneproxy.pro\/pl\/wiki\/subtyping\/","title":{"rendered":"Podtypowanie"},"content":{"rendered":"

Podtypy to podstawowe poj\u0119cie w informatyce i in\u017cynierii oprogramowania, stosowane g\u0142\u00f3wnie w j\u0119zykach programowania i systemach obiektowych. Odgrywa kluczow\u0105 rol\u0119 w tworzeniu elastycznych i wydajnych system\u00f3w, umo\u017cliwiaj\u0105c ponowne wykorzystanie kodu, polimorfizm i nie tylko. W kontek\u015bcie sieci serwer\u00f3w proxy podtypy umo\u017cliwiaj\u0105 wydajn\u0105 obs\u0142ug\u0119 r\u00f3\u017cnych typ\u00f3w serwer\u00f3w proxy, zwi\u0119kszaj\u0105c wydajno\u015b\u0107, bezpiecze\u0144stwo i skalowalno\u015b\u0107. W tym artykule om\u00f3wiono koncepcj\u0119 podtypu, jego histori\u0119, implementacj\u0119, kluczowe funkcje, typy i znaczenie dla dostawcy serwera proxy, firmy OneProxy.<\/p>\n

Historia powstania podtypu i jego pierwsza wzmianka<\/h2>\n

Koncepcja podtyp\u00f3w si\u0119ga pocz\u0105tk\u00f3w j\u0119zyk\u00f3w programowania. Alan Kay, pionier programowania obiektowego, wprowadzi\u0142 termin \u201epodtyp\u201d w 1966 roku, pracuj\u0105c nad rozwojem Simuli, pierwszego obiektowego j\u0119zyka programowania. W Simula Kay wykorzysta\u0142 podtypy do tworzenia hierarchii klas, umo\u017cliwiaj\u0105c ponowne wykorzystanie kodu i zapewniaj\u0105c podstaw\u0119 dla polimorfizmu.<\/p>\n

Szczeg\u00f3\u0142owe informacje o podtypach: Rozszerzenie tematu<\/h2>\n

Istota podtypowania<\/h3>\n

Podtypy to relacja mi\u0119dzy typami, w kt\u00f3rej jeden typ mo\u017cna uzna\u0107 za wyspecjalizowan\u0105 wersj\u0119 innego. Umo\u017cliwia tworzenie hierarchii, w kt\u00f3rych ka\u017cdy podtyp dziedziczy w\u0142a\u015bciwo\u015bci i zachowania od swojego nadtypu, potencjalnie dodaj\u0105c w\u0142asne, unikalne cechy. Ta relacja u\u0142atwia organizacj\u0119 kodu, mo\u017cliwo\u015b\u0107 ponownego u\u017cycia i zasad\u0119 substytucyjno\u015bci.<\/p>\n

Polimorfizm i podtypy<\/h3>\n

Jedn\u0105 z kluczowych zalet podtyp\u00f3w jest umo\u017cliwienie polimorfizmu. Polimorfizm umo\u017cliwia traktowanie r\u00f3\u017cnych podtyp\u00f3w jako przyk\u0142ad\u00f3w ich wsp\u00f3lnego nadtypu, co zwi\u0119ksza elastyczno\u015b\u0107 kodu i zmniejsza potrzeb\u0119 jawnego sprawdzania typu. Wykorzystuj\u0105c polimorfizm, dostawcy serwer\u00f3w proxy, tacy jak OneProxy, mog\u0105 efektywnie zarz\u0105dza\u0107 r\u00f3\u017cnymi typami serwer\u00f3w proxy bez skomplikowanych struktur rozga\u0142\u0119zie\u0144.<\/p>\n

Podtyp behawioralny<\/h3>\n

Opr\u00f3cz klasycznych relacji podtyp\u00f3w opartych na dziedziczeniu istnieje inna koncepcja zwana \u201epodtypami behawioralnymi\u201d. Podtypy behawioralne podkre\u015blaj\u0105 znaczenie zachowania obiektu, a nie jego hierarchii klas lub typ\u00f3w. W tym podej\u015bciu dwa typy s\u0105 uwa\u017cane za podtypy, je\u015bli wykazuj\u0105 identyczne zachowania, niezale\u017cnie od ich faktycznego zwi\u0105zku dziedziczenia. Takie podej\u015bcie mo\u017ce zwi\u0119kszy\u0107 elastyczno\u015b\u0107 i promowa\u0107 programowanie oparte na interfejsach.<\/p>\n

Wewn\u0119trzna struktura podtypowania: jak dzia\u0142a podtypowanie<\/h2>\n

Zasadniczo podtypowanie osi\u0105ga si\u0119 poprzez dziedziczenie klas w obiektowych j\u0119zykach programowania. Kiedy jedna klasa dziedziczy po drugiej, uzyskuje dost\u0119p do w\u0142a\u015bciwo\u015bci i metod swojej klasy nadrz\u0119dnej, w efekcie staj\u0105c si\u0119 podtypem klasy nadrz\u0119dnej. Dzi\u0119ki temu instancje podtypu mog\u0105 by\u0107 u\u017cywane wsz\u0119dzie tam, gdzie oczekiwane s\u0105 instancje nadtypu.<\/p>\n

Rozwa\u017cmy na przyk\u0142ad sie\u0107 serwer\u00f3w proxy z r\u00f3\u017cnymi typami serwer\u00f3w proxy, takimi jak proxy HTTP, SOCKS i SSL. Te typy proxy mo\u017cna zorganizowa\u0107 w hierarchi\u0119 podtyp\u00f3w, z og\u00f3lnym typem \u201eProxy\u201d na g\u00f3rze. Bardziej wyspecjalizowane typy, takie jak \u201eHTTPProxy\u201d, \u201eSOCKSProxy\u201d i \u201eSSLProxy\u201d mog\u0105 dziedziczy\u0107 po typie \u201eProxy\u201d, dziedzicz\u0105c jego wsp\u00f3lne cechy, potencjalnie dodaj\u0105c w\u0142asne, specyficzne funkcjonalno\u015bci.<\/p>\n

Analiza kluczowych cech podtypu<\/h2>\n

Podtypy wnosz\u0105 kilka kluczowych funkcji do tworzenia oprogramowania i sieci serwer\u00f3w proxy:<\/p>\n

    \n
  1. \n

    Mo\u017cliwo\u015b\u0107 ponownego wykorzystania kodu:<\/strong> Podtypy umo\u017cliwiaj\u0105 zdefiniowanie wsp\u00f3lnej funkcjonalno\u015bci w nadtypie, udost\u0119pniaj\u0105c j\u0105 wszystkim jego podtypom. Zmniejsza to powielanie kodu i zwi\u0119ksza \u0142atwo\u015b\u0107 konserwacji.<\/p>\n<\/li>\n

  2. \n

    Wielopostaciowo\u015b\u0107:<\/strong> Mo\u017cliwo\u015b\u0107 traktowania podtyp\u00f3w jako instancji ich wsp\u00f3lnego nadtypu upraszcza kod i umo\u017cliwia bardziej elastyczne implementacje.<\/p>\n<\/li>\n

  3. \n

    Zorganizowane hierarchie:<\/strong> Podtypy u\u0142atwiaj\u0105 tworzenie przejrzystych hierarchii reprezentuj\u0105cych relacje mi\u0119dzy r\u00f3\u017cnymi typami, poprawiaj\u0105c struktur\u0119 kodu i czytelno\u015b\u0107.<\/p>\n<\/li>\n

  4. \n

    Rozci\u0105gliwo\u015b\u0107:<\/strong> Nowe typy proxy mo\u017cna \u0142atwo dodawa\u0107 do sieci, definiuj\u0105c je jako podtypy istniej\u0105cych typ\u00f3w proxy, dziedzicz\u0105c ich funkcje.<\/p>\n<\/li>\n

  5. \n

    Zamienno\u015b\u0107:<\/strong> Podtyp\u00f3w mo\u017cna u\u017cywa\u0107 zamiennie z ich nadtypem, promuj\u0105c modu\u0142owo\u015b\u0107 i elastyczno\u015b\u0107.<\/p>\n<\/li>\n<\/ol>\n

    Rodzaje podtyp\u00f3w: korzystanie z tabel i list<\/h2>\n

    W j\u0119zykach programowania podtypy mo\u017cna podzieli\u0107 na dwa g\u0142\u00f3wne typy: podtyp nominalny<\/strong> I podtyp strukturalny<\/strong>.<\/p>\n

    Podtyp nominalny<\/h3>\n

    Podtypy nominalne opieraj\u0105 si\u0119 na jawnych deklaracjach typ\u00f3w i hierarchiach klas. W tym podej\u015bciu relacja mi\u0119dzy typami opiera si\u0119 na ich nazwach lub jawnych adnotacjach typ\u00f3w. W j\u0119zykach takich jak Java i C++ stosuje si\u0119 g\u0142\u00f3wnie podtypy nominalne.<\/p>\n

    Podtypy strukturalne<\/h3>\n

    Podtyp strukturalny, znany r\u00f3wnie\u017c jako \u201etypowanie kacze\u201d, okre\u015bla podtyp na podstawie struktury lub kszta\u0142tu typ\u00f3w. Dwa typy s\u0105 uwa\u017cane za podtypy, je\u015bli maj\u0105 ten sam zestaw w\u0142a\u015bciwo\u015bci i metod, niezale\u017cnie od ich nazw. J\u0119zyki takie jak Python i TypeScript obs\u0142uguj\u0105 podtypy strukturalne.<\/p>\n

    Poni\u017cej znajduje si\u0119 por\u00f3wnanie podtyp\u00f3w nominalnych i strukturalnych:<\/p>\n\n\n\n\n\n\n\n\n\n
    Funkcja<\/th>\nPodtyp nominalny<\/th>\nPodtypy strukturalne<\/th>\n<\/tr>\n<\/thead>\n
    Czynnik decyduj\u0105cy<\/td>\nWpisz nazwy i hierarchi\u0119<\/td>\nStruktura i mo\u017cliwo\u015bci<\/td>\n<\/tr>\n
    Ograniczenia deklaracji<\/td>\nJawne adnotacje typu<\/td>\nWsp\u00f3lne metody i zestawy w\u0142a\u015bciwo\u015bci<\/td>\n<\/tr>\n
    Przyk\u0142adowe j\u0119zyki<\/td>\nJava, C++, Swift<\/td>\nPython, TypeScript<\/td>\n<\/tr>\n
    Elastyczno\u015b\u0107<\/td>\nSztywny<\/td>\nElastyczny<\/td>\n<\/tr>\n
    Kontrola kompilacji<\/td>\nStatyczny<\/td>\nStatyczne lub dynamiczne<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    Sposoby korzystania z podtyp\u00f3w, problem\u00f3w i rozwi\u0105za\u0144<\/h2>\n

    Korzystanie z podtyp\u00f3w w sieciach serwer\u00f3w proxy<\/h3>\n

    W kontek\u015bcie sieci serwer\u00f3w proxy podtypy mog\u0105 znacznie usprawni\u0107 obs\u0142ug\u0119 r\u00f3\u017cnych typ\u00f3w serwer\u00f3w proxy. Tworz\u0105c hierarchi\u0119 podtyp\u00f3w dla r\u00f3\u017cnych protoko\u0142\u00f3w proxy, OneProxy mo\u017ce zaimplementowa\u0107 wsp\u00f3lne funkcje w og\u00f3lnym typie \u201eProxy\u201d, jednocze\u015bnie umo\u017cliwiaj\u0105c wyspecjalizowane zachowania w podtypach.<\/p>\n

    Na przyk\u0142ad, je\u015bli istnieje potrzeba obs\u0142ugi serwer\u00f3w proxy HTTP, SOCKS i SSL, ka\u017cdy typ serwera proxy mo\u017ce by\u0107 reprezentowany jako podtyp typu \u201eProxy\u201d. Umo\u017cliwia to OneProxy jednolite traktowanie wyst\u0105pie\u0144 r\u00f3\u017cnych typ\u00f3w serwer\u00f3w proxy, upraszczaj\u0105c zarz\u0105dzanie i zmniejszaj\u0105c z\u0142o\u017cono\u015b\u0107.<\/p>\n

    Problemy i rozwi\u0105zania<\/h3>\n

    Chocia\u017c podtypowanie ma wiele zalet, mo\u017ce r\u00f3wnie\u017c prowadzi\u0107 do pewnych wyzwa\u0144, takich jak:<\/p>\n

      \n
    1. \n

      Z\u0142o\u017cono\u015b\u0107 hierarchii dziedziczenia:<\/strong> G\u0142\u0119bokie i z\u0142o\u017cone hierarchie dziedziczenia mog\u0105 sta\u0107 si\u0119 trudne w zarz\u0105dzaniu i utrzymaniu, co mo\u017ce prowadzi\u0107 do potencjalnego rozd\u0119cia kodu.<\/p>\n<\/li>\n

    2. \n

      Niesp\u00f3jne zachowanie w podtypach:<\/strong> Podtypy mog\u0105 zast\u0105pi\u0107 lub doda\u0107 nowe zachowanie, co mo\u017ce powodowa\u0107 niesp\u00f3jno\u015bci i nieoczekiwane rezultaty.<\/p>\n<\/li>\n<\/ol>\n

      Aby z\u0142agodzi\u0107 te problemy, mo\u017cna zastosowa\u0107 odpowiednie wzorce projektowe, takie jak faworyzowanie kompozycji nad dziedziczeniem. Ponadto staranne planowanie hierarchii podtyp\u00f3w mo\u017ce pom\u00f3c w utrzymaniu r\u00f3wnowagi mi\u0119dzy ponownym wykorzystaniem kodu a elastyczno\u015bci\u0105.<\/p>\n

      G\u0142\u00f3wna charakterystyka i por\u00f3wnania z podobnymi terminami<\/h2>\n\n\n\n\n\n\n\n\n
      Termin<\/th>\nCharakterystyka<\/th>\nPor\u00f3wnanie<\/th>\n<\/tr>\n<\/thead>\n
      Podtypowanie<\/td>\nHierarchiczne relacje mi\u0119dzy typami<\/td>\nPodtyp jest wyspecjalizowan\u0105 wersj\u0105 swojego nadtypu<\/td>\n<\/tr>\n
      Wielopostaciowo\u015b\u0107<\/td>\nTraktowanie podtyp\u00f3w jako instancji wsp\u00f3lnego nadtypu<\/td>\nW\u0142\u0105czone przez podtyp<\/td>\n<\/tr>\n
      Dziedzictwo<\/td>\nMechanizm ponownego wykorzystania kodu poprzez hierarchie klas<\/td>\nS\u0142u\u017cy do ustanawiania relacji podtyp\u00f3w<\/td>\n<\/tr>\n
      Podtyp behawioralny<\/td>\nPodtypy oparte na podobnym zachowaniu, a nie na hierarchii<\/td>\nUzupe\u0142nia klasyczne podtypy w OOP<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

      Perspektywy i przysz\u0142e technologie zwi\u0105zane z podtypami<\/h2>\n

      Podtypy to koncepcja dobrze ugruntowana w programowaniu i oczekuje si\u0119, \u017ce pozostanie podstawowym aspektem in\u017cynierii oprogramowania. W miar\u0119 ewolucji j\u0119zyk\u00f3w programowania i pojawiania si\u0119 nowych paradygmat\u00f3w podtypy prawdopodobnie nadal b\u0119d\u0105 odgrywa\u0107 istotn\u0105 rol\u0119 w organizacji kodu, jego ponownym u\u017cyciu i polimorfizmie.<\/p>\n

      Wraz z pojawieniem si\u0119 zaawansowanych system\u00f3w typ\u00f3w i funkcji j\u0119zykowych programi\u015bci mog\u0105 dysponowa\u0107 pot\u0119\u017cniejszymi narz\u0119dziami do wyra\u017cania i egzekwowania relacji podtyp\u00f3w. Ponadto post\u0119p w podtypach behawioralnych mo\u017ce prowadzi\u0107 do powstania bardziej elastycznych i solidnych system\u00f3w, w kt\u00f3rych obiekty o r\u00f3\u017cnych hierarchiach b\u0119d\u0105 nadal mog\u0142y by\u0107 u\u017cywane zamiennie w zale\u017cno\u015bci od ich zachowania.<\/p>\n

      Jak serwery proxy mog\u0105 by\u0107 u\u017cywane lub kojarzone z podtypami<\/h2>\n

      Sieci serwer\u00f3w proxy mog\u0105 znacz\u0105co zyska\u0107 na podtypach. Implementuj\u0105c hierarchi\u0119 podtyp\u00f3w dla r\u00f3\u017cnych protoko\u0142\u00f3w proxy, dostawcy tacy jak OneProxy mog\u0105 efektywnie zarz\u0105dza\u0107 r\u00f3\u017cnymi serwerami proxy. Takie podej\u015bcie pozwala im dzieli\u0107 wsp\u00f3ln\u0105 funkcjonalno\u015b\u0107 na r\u00f3\u017cnych typach serwer\u00f3w proxy, co prowadzi do bardziej modu\u0142owej i \u0142atwiejszej w utrzymaniu bazy kodu.<\/p>\n

      Na przyk\u0142ad OneProxy mo\u017ce zdefiniowa\u0107 og\u00f3lny typ \u201eProxy\u201d, kt\u00f3ry obejmuje wsp\u00f3lne funkcje, takie jak filtrowanie adres\u00f3w IP, obs\u0142uga \u017c\u0105da\u0144 i rejestrowanie. Podtypy takie jak \u201eHTTPProxy\u201d i \u201eSOCKSProxy\u201d mog\u0105 nast\u0119pnie dziedziczy\u0107 po \u201eProxy\u201d, rozszerzaj\u0105c go o zachowania specyficzne dla protoko\u0142u.<\/p>\n

      powi\u0105zane linki<\/h2>\n

      Aby uzyska\u0107 wi\u0119cej informacji na temat podtyp\u00f3w i ich zastosowa\u0144:<\/p>\n

        \n
      1. Koncepcje programowania obiektowego<\/a><\/li>\n
      2. Podtyp nominalny i strukturalny<\/a><\/li>\n
      3. Zasada podstawienia Liskowa<\/a><\/li>\n
      4. Sieci serwer\u00f3w proxy i ich przypadki u\u017cycia<\/a><\/li>\n<\/ol>\n

        Podsumowuj\u0105c, podtypy to pot\u0119\u017cna koncepcja, kt\u00f3ra le\u017cy u podstaw wielu aspekt\u00f3w tworzenia nowoczesnego oprogramowania, w tym sieci serwer\u00f3w proxy. Zrozumienie podtyp\u00f3w i ich r\u00f3\u017cnych zastosowa\u0144 mo\u017ce pom\u00f3c programistom i dostawcom proxy, takim jak OneProxy, w budowaniu skalowalnych, elastycznych i wydajnych system\u00f3w dla swoich u\u017cytkownik\u00f3w.<\/p>","protected":false},"featured_media":479195,"menu_order":0,"template":"","meta":{"_acf_changed":false,"content-type":"","inline_featured_image":false,"footnotes":""},"class_list":["post-479194","wiki","type-wiki","status-publish","has-post-thumbnail","hentry"],"acf":{"faq_title":"Frequently Asked Questions about Subtyping: Understanding the Power of Type Hierarchies in Proxy Server Networks<\/mark>","faq_items":[{"question":"What is subtyping, and how does it relate to proxy server networks?","answer":"

        Subtyping is a concept in programming where one type is considered a specialized version of another type. In the context of proxy server networks, subtyping allows for the efficient handling of various proxy types. By creating a subtype hierarchy, common functionality can be defined in a generic \"Proxy\" type, while specialized behaviors are implemented in the subtypes like \"HTTPProxy,\" \"SOCKSProxy,\" and \"SSLProxy.\" This approach simplifies proxy management and promotes code reusability and flexibility.<\/p>"},{"question":"Who introduced the concept of subtyping, and when was it first mentioned?","answer":"

        Subtyping was introduced by Alan Kay, a pioneer in object-oriented programming, in 1966 while working on the development of the Simula programming language. The term \"subtype\" was first mentioned in the context of creating hierarchies of classes to enable code reuse and polymorphism.<\/p>"},{"question":"How does subtyping work internally?","answer":"

        Subtyping is achieved through class inheritance in object-oriented programming languages. When one class inherits from another, it becomes a subtype of the parent class and gains access to its properties and methods. This enables instances of the subtype to be used wherever instances of the supertype are expected, promoting code reusability and polymorphism.<\/p>"},{"question":"What are the key features of subtyping?","answer":"

        The key features of subtyping include:<\/p>

        1. Code Reusability: Subtyping allows common functionality to be defined in a supertype, reducing code duplication.<\/li>
        2. Polymorphism: Subtypes can be treated as instances of their common supertype, enabling flexible implementations.<\/li>
        3. Organized Hierarchies: Subtyping facilitates the creation of clear hierarchies that represent relationships between different types.<\/li>
        4. Extensibility: New types can be easily added to the hierarchy as subtypes of existing types, inheriting their features.<\/li>
        5. Interchangeability: Subtypes can be used interchangeably with their supertype, promoting modularity and flexibility.<\/li><\/ol>"},{"question":"What types of subtyping exist in programming languages?","answer":"

          There are two main types of subtyping:<\/p>

          1. Nominal Subtyping: It relies on explicit type declarations and class hierarchies, where types are related based on their names or explicit type annotations. Languages like Java and C++ predominantly use nominal subtyping.<\/p><\/li>

          2. Structural Subtyping: Also known as \"duck typing,\" it determines subtyping based on the structure or shape of types. Two types are considered subtypes if they share the same set of properties and methods, regardless of their names. Languages like Python and TypeScript support structural subtyping.<\/p><\/li><\/ol>"},{"question":"How can subtyping be used in proxy server networks?","answer":"

            In proxy server networks, subtyping can significantly enhance proxy management. By organizing proxy types into a subtype hierarchy, providers like OneProxy can implement shared functionality in a generic \"Proxy\" type and allow specialized behaviors in the subtypes. This approach simplifies proxy handling, reduces complexity, and promotes code reusability.<\/p>"},{"question":"What are the potential problems with subtyping, and how can they be addressed?","answer":"

            Some potential problems with subtyping include:<\/p>

            1. Inheritance Hierarchy Complexity: Deep and complex inheritance hierarchies can become challenging to manage and maintain.<\/p><\/li>

            2. Inconsistent Behavior in Subtypes: Subtypes may override or add new behavior, leading to inconsistencies and unexpected results.<\/p><\/li><\/ol>

              To address these issues, developers can use proper design patterns, like favoring composition over inheritance, and carefully plan the subtype hierarchy to maintain a balance between code reuse and flexibility.<\/p>"},{"question":"How does subtyping compare with similar terms like polymorphism and inheritance?","answer":"

              Subtyping is a relationship between types, where one type is a specialized version of another. It enables polymorphism, which allows different subtypes to be treated as instances of their common supertype. Inheritance, on the other hand, is a mechanism for code reuse through class hierarchies, used to establish subtyping relationships. Subtyping also includes a concept known as behavioral subtyping, where types are related based on their shared behavior, not just their class hierarchy.<\/p>"},{"question":"What are the perspectives and future technologies related to subtyping?","answer":"

              Subtyping is expected to remain a fundamental concept in software engineering. As programming languages evolve, developers may have more powerful tools to express and enforce subtyping relationships. Advancements in behavioral subtyping could lead to more flexible and robust systems, where objects with different hierarchies can still be used interchangeably based on their behavior.<\/p>"},{"question":"How are proxy servers associated with subtyping?","answer":"

              Proxy server networks can benefit from subtyping by organizing different proxy types into a subtype hierarchy. This approach allows providers like OneProxy to share common functionality in a generic \"Proxy\" type while enabling specialized behaviors in subtypes. This enhances proxy management, code modularity, and maintainability.<\/p>"}]},"_links":{"self":[{"href":"https:\/\/oneproxy.pro\/pl\/wp-json\/wp\/v2\/wiki\/479194","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/oneproxy.pro\/pl\/wp-json\/wp\/v2\/wiki"}],"about":[{"href":"https:\/\/oneproxy.pro\/pl\/wp-json\/wp\/v2\/types\/wiki"}],"version-history":[{"count":0,"href":"https:\/\/oneproxy.pro\/pl\/wp-json\/wp\/v2\/wiki\/479194\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/oneproxy.pro\/pl\/wp-json\/wp\/v2\/media\/479195"}],"wp:attachment":[{"href":"https:\/\/oneproxy.pro\/pl\/wp-json\/wp\/v2\/media?parent=479194"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}