Val Do-ს ბლოგი

ასევე, თუ თქვენი კურსი არის ინგლისურ ენაზე და არ მესმის კარგად რასაც საუბრობს ლექტორი, ვრთავ ე.წ. ტიტრებს და ისე ვაგრძელებ მოსმენას და თუ მაინც ისეთი სიტყვა ვიპოვე, რომელიც აქამდე არ ვიცოდი ვიყენებ გადათარგმნის ონლიან სერვისებს ისეთებს, როგორებიცაა: translate.google.com ან translate.ge

მოცემული მეთოდი მეხმარება გაკვეთილის პირველად ყურებისას გავიაზრო თუ რის გაკეთებას ცდილობს ლექტორი და რა პროექტი თუ ამოცანები უნდა გადაჭრას მოცემულ გაკვეთილში.

აუცილებელი მოთხოვნაა, პირველად გაკვეთილის მოსმენისას არ დავიწყო მასთან ერთად კოდის წერა და უბრალოდ გულდასმით ვუსმინო კურსის ბოლომდე.

პროგრამირების შესწავლის მეორე საფეხური

მას შემდეგ რაც გაკვეთილს ბოლომდე მოვისმენ, უკვე მექმნება წარმოდგენა თუ როგორ მუშაობს მთლიანად ენა, როგორ ხდება ცვლადების აღწერა, მონაცემების გაცვლა და ა.შ.

როდესაც მეორედ ვიწყებ გაკვეთილის მოსმენას უკვე ლექტორთან ერთად ვცდილობ ავაწყო ზუსტად ის პროექტი, რასაც თავად ლექტორი აკეთებს, სწორედ ამ პროცესის გავლისას უკვე გონებაში ნელ-ნელა ჯდება ის განვლილი პროგრამირების თეორია, რომელიც პირველად მოვისმინე.

აუცილებელია მეორედ მოსმენის დროს არ გავჩერდეთ და აუცილებლად მივაღწიოთ კურსში განვლილი პროექტის ფინალურ ფაზას, ანუ უნდა ავაწყოთ ზუსტად ის რასაც ლექტორი გვასწავლის.

პროგრამირების შესწავლის ფინალური ფაზა.

შესწავლის ფინალური ფაზა წარმოადგენს ჩემს პროექტს, რომელსაც ვცდილობ ავაწყო აღნიშნულ ტექნოლოგიაზე, მაგრამ მაინც ვცდილობ პროექტის თემატიკა ძალიან არ განსხვავდებოდეს კურსში არსებული პროექტის თემატიკისგან, ანუ ვცდილობ მივამატო ახალი ფუნქციონალი, რომელიც გაკვეთილში იყო გამოყენებული, უბრალოდ ვცდილობ მცირე მოდიფიკაცია გავუკეთო და დამოუკიდებლად ვცადო კურსში განხილული თემების პრაქტიკაში გამოყენება.

არსებული მიდგომა მეხმარება პრობლემის შემთხვევაში დავუბრუნდე კურსის იმ ქვეთავს, რომელსაც კარგად ვერ ვიგებ და გავიხსენო ლექტორის მიერ ახსნილი მასალა.

პროგრამირების შესწავლის ფინალური ფაზა უკვე პროექტის სრულიად დამოუკიდებლად აწყობის მცდელობაა, მაგრამ არ უნდა დაგავიწყდეთ, რომ არ ხართ შეზღუდული განვლილი მასალის გადამეორებაში.

გახსოვდეთ როდესაც რაიმეს ვერ გაიგებთ, აუცილებელია გადახედოთ განვლილ მასალას ან ჩაიხედოთ პროგრამირების ენის დოკუმენტაციაში.

პროგრამირების უფასო კურსები ქართულად

• HTML, CSS-ის კურსი დამწყებთათვის
• JavaScript-ის კურსი დამწყებთათვის
• JavaScript-ის DOM დამწყებთათვის
• TypeScript-ის კურსი დამწყებთათვის
• Angular-ის კურსი დამწყებთათვის
• ReactJS-ის კურსი დამწყებთათვის
• ალგორითმების კურსი დამწებთათვის

დღევანდელ ბლოგში და ასევე ვიდეოში, რომელიც YouTube-ზე უკვე დევს ვისაბუბრებ web safe და browser safe-ფონტებზე.

არსებობენ სტანდარტული ფონტები, რომლებიც მოყვება ნებისმიერ ოპერაციულ სისტემას და არ აქვს მნიშვნელობა თუ რომელი სისიტემაა ის, იქნება ეს Windows, Mac os თუ Linux-ის ნებისმიერი დისტრიბუცია.

web safe ფონტებს ძირითადად ორი გამოყენება აქვთ, პირველი ის, რომ თუ ჩვენ მხოლოდ მათ გამოვიყენებთ დარწმუნებული ვიქნებით, რომ ჩვენი ფონტი ნებისმიერ ოპერაციულ სისტემაში ზუსტად ისე გამოჩნდება, როგორც ჩვენს ეკრანზე.

რაც შეეხება მეორე ვერსიას, web safe ფონტები ასევე გამოიყენება იმ შემთხვევისთვის თუ ჩვენი ე.წ. (custom) ფონტი სწორად არ ჩაიტვირთება, ამ შემთხვევაში მოერე ვერსიად ასევე შეიძლება გვქონდეს web safe ფონტი.

• ბრაუზერი (chrome, firefox, opera...)
• ტექსტური რედაქტორი ან ე.წ. IDE (VS Code, Web Storm, Sublime text, Vim/NeoVim...)
• Git Bash

როგორც ზემოთ ჩამოთვლილში ხედავთ, ვებ პროგრამირების შესწავლის დასაწყებად ძალიან ცოტა პროგრამაა საჭირო, შესაბამისად ის წარმოდგენები, რომ ჩვენ აუცლებელია შევიძინოთ ე.წ. სუპერკომპიუტერი და შედარებით ბიუჯეტური კომპიუტერით არ გამოგვივა პროგრამირება, არის მცდარი.

რა მინიმალური მონაცემები უნდა ქონდეს კომპიუტერს?

მოდი განვსაზღვროთ მინიმალური მოთხოვნები კომპიუტერისთვის, რომელიც უნდა გავითვალისწინოთ შეძენის დროს. ამის გასარკვევად აუცილებელია კომპიუტერი აკმაყოფილებდეს პროგრამების გაშვებისთვის საჭირო მოთხოვნებს.

მაგალითისთვის, რომ გავუშვათ chrome-ის ბრაუზერი, როგორც მათ საიტზე ვკითხულობთ, აუცილებელია მინიმუმ კომპიუტერის პროცესორს ქონდეს 2GHz-ზე მეტი სიხშირე, ხოლო რაც შეეხება ოპერატიულ მეხსიერებას, სასურველია იყოს მინიმუმ 4GB და მყარი დისკის მოცულობა იყოს მინიმუმ 256GB

ასევე, აღსანიშნავია რომ თუ გამოვიყენებთ კოდის წერისთვის თანამედროვე IDE-ებს როგორიცაა მაგალითად Web Storm, მათ საკმაოდ უყვართ დიდი რაოდენობის ოპერატიული მეხსიერების გამოყენება, ისევე როგორც ჩვენს ბრაუზერებს, ამიტომ გაითვალისწინეთ, რომ თუ თქვენ მინიმალური მონაცემების კომპიუტერს იყიდით დეველოპმენტის დრო შესაძლოა გაგიგრძელდეთ, კომპიუტერის სისწრაფიდან გამომდინარე.

რომელი ოპერაციული სისტემა უნდა მქონდეს?

ვებ პროგრამირების სწავლის დაწყებისას ამას არ აქვს მნიშვნელობა, მთავარია თქვენ სად გრძნობთ თავს კომფორტულად იქნება ეს Windows, Mac OS თუ Linux, მაგრამ, მე, ჩემი გამოცდილებით, Linux-ს და Mac OS-ს მივანიჭებდი უპირატესობას, რადგანაც ისინი დაშენებულია UNIX-ზე

საიდან დავიწყოთ ვებ პროგრამირების შესწავლა?

ვებ პროგრამირების შესასწავლად უამრავი ინგლისურენოვანი ინტერნეტ რესურსი არსებობს, მაგრამ თუ თქვენთვის ინგლისური ბარიერს წარმოადგენს, შეგიძლიათ val-do.com-ზე ან Val Do-ს YouTube არხზე შეისწავლოთ 0-დან, საიტზე მოცემულია შემდეგი უფასო კურსები:

• HTML, CSS-ის კურსი დამწყებთათვის
• JavaScript-ის კურსი დამწყებთათვის
• JavaScript-ის DOM დამწყებთათვის
• TypeScript-ის კურსი დამწყებთათვის
• Angular-ის კურსი დამწყებთათვის
• ReactJS-ის კურსი დამწყებთათვის
• ალგორითმების კურსი დამწებთათვის

tmux-ის რეპოზიტორი გითზე

tmux-ის სესიების კომბინაციები (sessions)

tmux-ის ფანჯრების კომბინაციები (windows)

tmux-ის Pane-ების კომბინაციები (split screen)

<!doctype html>
<html lang="ka">

<head>
  <meta charset="utf-8">
  <title>თქვენი საიტის სათაური</title>
  <base href="/">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <!-- fav icon -->
  <link rel="icon" type="image/png" href="./assets/icons/logo.png">
  <!-- open graph meta tags -->
  <meta name="og:type" content="website" />
  <meta name="og:title" content="" />
  <meta name="og:description" content="" />
  <meta name="og:url" content="" />
  <meta name="og:image" content="" />
  <meta name="image" content="" />
  <!-- twitter meta tags -->
  <meta name="twitter:card" content="" />
  <meta name="twitter:site" content="" />
  <meta name="twitter:creator" content="" />
  <meta name="twitter:description" content="" />
  <meta name="twitter:url" content="" />
  <meta name="twitter:image" content="" />
</head>
...

ng g s meta

import { Injectable } from '@angular/core';
import { Meta, Title } from '@angular/platform-browser';
import { Router } from '@angular/router';
import { environment } from 'src/environments/environment';

@Injectable({
  providedIn: 'root'
})
export class MetaService {

  constructor(
    private _title: Title,
    private _meta: Meta,
    private _router: Router
  ) {
  }

  update(
    title: string,
    description: any,
    img?: string
  ) {
    /* page title */
    this._title.setTitle(title);
    /* meta tags */
    this._meta.updateTag({name: 'description', content: `${description.replace(/(<([^>]+)>)/gi, "").slice(0, 145)}...`});
    this._meta.updateTag({name: 'author', content: `Val Do`});
    /* open graph */
    this._meta.updateTag({ name: 'og:title', content: title });
    this._meta.updateTag({ name: 'og:description', content: `${description.replace(/(<([^>]+)>)/gi, "").slice(0, 145)}...` });
    this._meta.updateTag({ name: 'og:url', content:`${environment.baseUrl}/${this._router.url.slice(1)}` });
    this._meta.updateTag({ name: 'og:image', content: img || `${environment.baseUrl}/assets/social.jpg` });
    this._meta.updateTag({ name: 'image', property: 'og:image', content: img || `${environment.baseUrl}/assets/social.jpg` });
    /* twitter */
    this._meta.updateTag({ name: 'twitter:card', content: 'summary_large_image' });
    this._meta.updateTag({ name: 'twitter:site', content: '@va1_do' });
    this._meta.updateTag({ name: 'twitter:creator', content: '@va1_do' });
    this._meta.updateTag({ name: 'twitter:title', content: title });
    this._meta.updateTag({ name: 'twitter:description', content: `${description.replace(/(<([^>]+)>)/gi, "").slice(0, 145)}...` });
    this._meta.updateTag({ name: 'twitter:url', content:`${environment.baseUrl}/${this._router.url.slice(1)}` });
    this._meta.updateTag({ name: 'twitter:image', content: img ||`${environment.baseUrl}/assets/social.jpg` });
  }
}

import { Component, OnInit } from '@angular/core';
import { MetaService } from './meta.service';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})

export class AppComponent implements OnInit{
  constructor(
    private _metaService: MetaService
  ) {}

  ngOnInit(): void {
    this._metaService.update(
      'თქვენი გვერდის სათაური',
      'თქვენი გვერდის აღწერა',
      'თქვენი გვერდის ფოტოს მისამართი path/img'
    )
  }

}

იმისთვის, რომ meta სერვისმა იმუშაოს სოციალურ ქსელებში აუცილებელია თქვენი პალიკაცია იყენებდეს Angular universal-ს ანუ server side rendering-ს

როგორც იცით, იმისთვის, რომ გუგლის საძიებო სისტემაში ჩვენი გვერდი ლამაზად მეტად ინფორმირებულად გამოჩნდეს საჭიროა schema.org-ის json-ld-ის გამოყენება.

სტრუქტურის ნიმუშების სანახავად შეგიძლიათ გადახვიდეთ მოცემულ ბმულზე

ანგულარ აპლიკაცას არ აქვს პირდაპირი მხარდაჭერა და სწორედ ამიტომ ავაწყე კომპონენტი, რომელიც უზრუნველყოფს დოკუმენტში json-ld-ის ინტეგრაციას.

პირველ რიგში დავაგენერიროთ კომპონენტი

ng g c json-ld

კომპონენტის გენერაციის შემდეგ, ჩვენი კომპონენტი უნდა გამოიყურებოდეს შემდეგნაირად

json-ld.component.ts

import { DOCUMENT } from '@angular/common';
import { AfterViewInit, Component, Inject, Input, Renderer2 } from '@angular/core';

@Component({
  selector: 'app-json-ld',
  templateUrl: './json-ld.component.html',
  styleUrls: ['./json-ld.component.scss']
})
export class JsonLdComponent implements AfterViewInit {

  @Input() data!: any;

  constructor(
    @Inject(DOCUMENT) private _document: Document,
    private _renderer2: Renderer2
  ) { }

  ngAfterViewInit(): void {
    const jsonLdElement: HTMLElement = this._document.querySelector('[type="application/ld+json"]') as HTMLElement;

    if (!jsonLdElement) {
      const script = this._renderer2.createElement('script');
      script.type = `application/ld+json`;
      script.text = JSON.stringify(this.data);
      this._renderer2.appendChild(this._document.head, script);
      return;
    }

    jsonLdElement.innerText = JSON.stringify(this.data);
  }

}

მას შემდეგ რაც კომპონენტს ავაწყობთ ჩვენ უკვე შეგვიძლია მას @Input() დეკორატორის დახმარებით სასურველი კომპონენტიდან გადმოვაწოდოთ ჩვენთვის სასურველი სტრუქტურის json.

მაგალითად წარმოვიდგინოთ, რომ გვაქვს ონლაინ მაღაზია და გვინდა json-ld-ის ინიციალიზაცია მაღაზიის პროდუქტებზე

product.component.ts

import { Component, OnInit } from '@angular/core';
import { Observable, tap } from 'rxjs';
import { ProductService } from '../services/product.service';

interface Product {
  title: string;
  description: string;
  images: string[];
  price: string;
}

@Component({
  selector: 'app-product',
  templateUrl: './product.component.html',
  styleUrls: ['./product.component.scss']
})
export class ProductComponent implements OnInit {

  product$!: Observable<Product>;
  schema!: any;

  constructor(
    private _productService: ProductService
  ) { }

  ngOnInit(): void {
    this.product$ = this._productService.getProduct().pipe(
      tap(product => {
        this.schema = {
          "@context": "https://schema.org/",
          "@type": "Product",
          "name": product.title,
          "img": product.images,
          "description": product.descr.replace(/(<([^>]+)>)/gi, "").slice(0, 145),
          "sku": product.product_id,
          "offers": {
            "@type": "AggregateOffer",
            "offerCount": product.quantity,
            "lowPrice": product.price,
            "highPrice": product.price,
            "priceCurrency": "GEL",
          }
        }
      })
    );
  }

}

product.component.html

<ng-container *ngIf="(product$|async) as product">
    ... თქვენი კოდი
    <app-json-ld [data]="schema"></app-json-ld>
</ng-container>

იმისათვის, რომ დაიწყოთ თქვენი fullstack კარიერა, აუცილებალია სრულყოფილად ფლობდებთ HTML, CSS ენებსა და მათ საფუძვლებს, რომელთა დახმარებითაც შეძლებთ ააწყოთ სტატიკური ვებ გვერდები.

ჩემი გამომწერების და საიტის მომხმარებლების მოთხოვნით, გადავწყვიტე შემექმნა კურსი, რომლის ფარგლებშიც პირადად მე ვიქნები თქვენი მენტორი და შევეცდები გაგიზიაროთ ჩემი ცოდნა და გამოცდილება.

ლექციები ჩატარდება კვირაში 2 დღე და მათი ხანგრძლივობა შეადგენს 1,5 საათს. შევხვდებით ონლაინ, ტელეგრამის საშუალებით, ასევე ჩავიწერთ ყველა ლექციას Full HD ფორმატში და გამოგიგზავნით ლექციის დასრულების შემდგომ.

კურსის სრული ხანგრძლივობა შეადგენს 22 საათს, რომლის ფარგლებშიც შეისწავლით HTML, CSS ენებს და მათი დახმარებით სტატიკური ვებ-გვერდების აწყობას.

კურსის დასრულების შემდეგ, სრულყოფილად შეძლებთ ააწყოთ კომპლექსური ვებ გვერდები.

*კურსის დასაწყებად აუცილებელია დარეგისტრირდეს მინიმუმ 10 სტუდენტი.

👉🏻 რეგისტრაცია

🤔 გაქვს კითხვები? 👉🏻 მომწერე აქ

*იმ შემთხვევაში, თუ კურსი არ მოგეწონებათ გადახდილი თანხა მთლიანად აგინაზღაურდებათ

რა მოხდება კურსის დასრულების შემდეგ?

* ყველაფერი ზუსტად ისევ ისე იქნება შენზე დამოკიდებული, როგორც აქამდე იყო, თუმცა თუ ეს პროფესია ნამდვილად შენთვისაა, შეიძენ საჭირო ცოდნას,  დააგროვებ საჭირო დოკუმენტაციასთან მუშაობის გამოცდილებას, შეიქმნი სწორ წარმოდგენებს მომავალზე, გადადგავ პირველ კარიერულ ნაბიჯებს და რაც მთავარია, არ დარჩები მოტყუებული ფუჭი დაპირებებით.

* დეველოპმენტის სწავლა მარტივი არ არის, თუმცა სურვილის და მონდომების შემთხვევაში აუცილებლად გამოგივა, ჩემი მიზანია დაგეხმარო.

* ყველა დეველოპერი ვერ გახდება, რადგან ისევე როგორც სხვა პროფესიები, გარკვეულ უნარებს მოითხოვს, თუმცა ცდად ნამდვილად ღირს.

* რამდენად სწრაფად დასაქმდები და რამდენ ნიშნიანი ხელფასი გექნება, შენს მონდომებაზეა დამოკიდებული, კურსის ფარგლებში მაქსიმალურად გაგიზიარებ ჩემს გამოცდილებას.

კურსის განმავლობაში შეისწავლით:

გადავწყვიტე ცოტა ხნით შევეშვა VS Code-ს და დავუბრუნდე Sublime Text 3 ედითორს, ამ სტატიაში შესული იქნება Sublime Text 3-ის ჩემებური კონფიგურაცია

Package control-ის ინსტალაცია

პირველ რიგში საბლაიმის გახსნისთანავე საჭიროა დავაყენოთ Package control.

გავხსნათ საბლაიმი და დავაწვეთ command(ctrl)+shift+p, რის შემდეგაც გამოვა ჩასაწერი ველი, რომელშიც უნდა ჩავწეროთ Install Package Control, ამის შემდეგ საბლაიმი თავისით შემოგვთავაზებს ვარიანტს და ავირჩიოთ შესაბამისი Install Package Control

File Icon-ის დაყენება

საბლაიმის ფაილ აიქონები ნამდვილად არაა ლამაზი და არ წარმოაჩენს ერთი შეხედვით ფაილის ტეპებს, სწორედ ამიტომ დავაყენოთ A File Icon-ის თემა.

1. ვაწვებით command(ctrl)+shift+p
2. ვკრეფთ Package control
3. ვირჩევთ Install Package
4. ვკრეფთ A File Icon და ვაწვებით ენთერს
5. გადავტვირთოთ საბლაიმი

Import Helper-ის დაყენება

ვინაიდან ხშირად გვიწევს ჯავასკრიპტთან მუშაობა საჭიროა კიდევ ერთი კარგი ფლაგინი, რომელიც ჯავასკრიპტ კოდის იმპორტში დაგვეხმარება.

ფლაგინის სახელია ImportHelper

1. ვაწვებით command(ctrl)+shift+p
2. ვკრეფთ Package control
3. ვირჩევთ Install Package
4. ვკრეფთ ImportHelper და ვაწვებით ენთერს

ფლაგინის გამოსაყენებელი ღილაკების კომბინაციაა ctrl+alt+i

Terminus-ის დაყენება

ვიზუალ სტუდიო კოდის ერთერთი ყველაზე დიდი პლიუსი ინტეგრირებული ტერმინალია, რომლის უქონლობასაც ძალიან განვიცდი საბლაიმში, სწორედ ამიტომ დავაყენოთ ინტეგრირებული ტერმინლაი სახელად Terminus

1. ვაწვებით command(ctrl)+shift+p
2. ვკრეფთ Package control
3. ვირჩევთ Install Package
4. ვკრეფთ Terminus და ვაწვებით ენთერს

ინსტალაციის შემდეგ გამოვიძახოთ ღილაკების კობმინაციით command(ctrl)+shift+p და მოვძებნოთ შემდეგი ტექსტი, Preferences: Terminus Key Bindings, მას შემდეგ რაც გაიხსნება პარამეტრები ცარიელ მხარეს ფაილის ჩავწეროთ შემდეგი კონფიგურაცია

[
	{ "keys": ["alt+`"], "command": "toggle_terminus_panel" },
	// Open a terminal tab at current file directory
    {
        "keys": ["ctrl+alt+t"], "command": "terminus_open", "args": {
            "cwd": "${file_path:${folder}}"
        }
    },
]

მოცემული კონფიგურაცია დაგვეხმარება მარტივად კლავიატურის დახმარებით გამოვიძახოთ Terminus-ი

alt+` გამოიძახებს ტერმინალს, ხოლო ctrl+alt+t გამოიძახებს ტერმინალს იმ დირექტორიაში რომელზეც ვდგავართ

კონფიგურაცია

როგორც იცით ერთ-ერთი ყველაზე გამოსადეგი ღილაკის კომბინაცია არის command(ctrl)+p, რომლის დახმარებითაც მარტივად შეგვიძლია გადავიდეთ სასურველ ფაილში, ფაილის დასახელების აკრეფით.

მაგრამ როდესაც ვმუშაობთ პროექტზე სადაც არის ისეთი დირექტირიები, როგორიცაა მაგალითად node_modules, ძალიან დიდ დისკომფორტს ქმნის ძიებისას node_modules-ს დირექტორიაში დამთხვეული ფაილის დასახელებები, სწორედ ამიტომ აუცილებელია საბლაიმის კონფიგურაციაში დავამატოთ არასასურველი დირექტორიების სია, რომლებზეც არ გვსურს ძიება გავრცელდეს.

კოფიგურაციის დასამატებლად აუცილებელია გავხსნათ საბლაიმის კოფიგურაციის json ფაილი Preferences > settings და დავამატოთ შემდეგი კოფიგურაცია

"folder_exclude_patterns": [
    	"node_modules/**",
    	".angular/**",
    	"dist/**",
    	".git/**"
 ]

ხაზის წაშლის ფუნქციონალი მაკზე

ვიზუალ სტუდიო კოდიდან გადმოყოლილი ჩვევა ხაზის წაშლაზე როგორც აღმოვაჩინე საბლაიმზეც დამჭირდა, მაგრამ აქ სხვა ღილაკების კომბინაციითაა, ctrl+shift+k, მაგრამ მაკზე ჩემთვის მოსახერხებელი კომბინაცია დავაყენე Preferences > Key Bindings

{ "keys": ["super+shift+k"], "command": "run_macro_file", "args": {"file": "res://Packages/Default/Delete Line.sublime-macro"} },

უბრალოდ ctrl ღილაკი შევცვალე command ღილაკით, ვინდოუსზე და ლინუქსზე თუ თქვენთვის სტანდარტული კომბინაცია მისაღებია შეგიძლიათ დატოვოთ

დირექტირიის გახსნა საიდ ბარში

Preferences > Key Bindings

{ "keys": ["super+shift+e"], "command": "reveal_in_side_bar" }

Emmet-ის დაყენება

1. ვაწვებით command(ctrl)+shift+p
2. ვკრეფთ Package control
3. ვირჩევთ Install Package
4. ვკრეფთ Emmet და ვაწვებით ენთერს