Archívum

programozás

Ha az Eclipse-et használod C++ projektek fejlesztésére, akkor könnyen belefuthatsz a következő üzenetbe.

A project Build-elése ugyan megtörténik, de a futtatás már a fenti hibaüzenettel elszáll. Vagyis ez nem is hibaüzenet, egyszerűen nincs megadva a Futtatási beállítások. Mi a teendő?

A projekt nevén jobb klikk és a menüből kiválasszuk a Properties menüpontot. Majd a Properties ablakban megkeresed a Run/Debug Settings menüt. Ha ez megvan létre kell hozni egy új környezetet a New… gomb megnyomásával. Itt alapvetően jó minden, de kedved szerint változtathatsz. Majd ha ez kész, akkor Apply and Close.

Maga az osztály, amit majd be szeretnénk tölteni a szokásos struktúrával rendelkezik:

<?php
// MyCaptcha.php
defined('BASEPATH') OR exit('No direct script access allowed');

class MyCaptcha
{
}

A helye az application/libraries alatt kell lennie.

Aztán irány az application/config/autoload.php fájl. Itt keressük meg ezt a sort és egészítsük ki hasonlóan.

$autoload['libraries'] = array('database', 'MyCaptcha');

Majd ha hivatkozni akarsz rá:

$this->mycaptcha->randomCaptchaPic();

CodeIgniter – version 3.1.7

create or replace function Haversine(
p1_lat double precision, 
p1_long double precision, 
p2_lat double precision, 
p2_long double precision
)
returns double precision as $tavolsag$
declare
	EarthRadius constant double precision = 6372.8;
	m_pi constant double precision = 3.1415926535;
	diffLat double precision;
	diffLong double precision;
	a double precision;

begin	
	diffLat = m_pi * (p2_lat - p1_lat) / 180;
	diffLong = m_pi * (p2_long - p1_long) / 180;
	
	p1_lat = m_pi * (p1_lat) / 180;
	p2_lat = m_pi * (p2_lat) / 180;
	
	a = sin(diffLat / 2) * sin(diffLat / 2) + sin(diffLong / 2) * 
		sin(diffLong / 2) * cos(p1_lat) * cos(p2_lat);
	return EarthRadius * 2 * asin(sqrt(a));	
end;
$tavolsag$ LANGUAGE plpgsql;

Kisvárda-Nyíregyháza távolság kilométerben.

TEST2=# select Haversine(48.21667, 22.08333, 47.95539, 21.71671);
 haversine 
------------------
 39.8318008206491
(1 row)

C++ forrás ebben a témában.

Metódus láncolás Javascript-ben.

var Person = function() {
	this.name = undefined;
	this.hairColor = undefined;
	this.height = undefined;
};

Person.prototype.setName = function(name) {
	this.name = name;
	return this;
}

Person.prototype.setHairColor = function(color) {
	this.hairColor = color;
	return this;
}

Person.prototype.setHeight = function(height) {
	this.height = height;
	return this;
}

var person1 = new Person()
	.setName("anon117")
	.setHairColor("brown")
	.setHeight(192);

var person2 = new Person().setName("Catriona").setHairColor("blond").setHeight(175);

var person3 = new Person();
person3.setName("Goldie").setHairColor("hazel").setHeight(190);

console.log(person1);
console.log(person2);
console.log(person3);

/*
{ name: 'anon117', hairColor: 'brown', height: 192 }
{ name: 'Catriona', hairColor: 'blond', height: 175 }
{ name: 'Goldie', hairColor: 'hazel', height: 190 }
*/

 

Néhány alap utasítás, essünk túl rajtuk:

var arr = ["alma", "körte", "dinnye", "cseresznye", "barack"];

console.log("elemek száma: " + arr.length);
arr.push("banán"); // Hozzáad a végéhez egy elemet
arr.pop(); // elvesz egy elemet a végéről.
arr.unshift("narancs"); // az elejéhez ad hozzá eg elemet
arr.shift(); // az elejéből vesz el egy elemet

A tömb másolása:

var arr2 = arr // referencia másolás

Ez a művelet „csak” a tömb referenciáját másolja, vagyis mindkét változó címe ugyanarra a tömbre mutat. A valódi másolat készítéséhez a slice() metódust használjuk.

var arrcopy = arr.slice();

Így az egész tömb másolódik, viszont paraméterben megadhatjuk a másolás kezdetét és végét. var arrcopy2 = arr.slice(1,3);.

Na, de nézzünk érdekesebb dolgokat. a tömbünket bejárhatjuk egy forEach() metódus segítségével. A forEach végiglépked az elemeken és hogy mit csináljunk vele egy callback függvénnyel dönthetjük el.

arr.forEach(function(elem, index){
  console.log("index: " + index + ", elem: " + elem);
})

// index: 0, elem: körte
// index: 1, elem: dinnye
// index: 2, elem: cseresznye
// index: 3, elem: barack

A filter() metódus, amely visszaad egy olyan tömböt, amelynek az elemei átmentek a callback függvény által megadott teszten.

var cbFilter = function(value, key) {
  if (key > 2)
    return true;
}

console.log(arr.filter(cbFilter));

a find metódus azon első értékét adja vissza, amire a callback függvény teszten átmegy, hasonlóan működik a findIndex, ami a megtalált elem indexét adja vissza.

var cbFindValue = function(elem) {
  if (elem === "cseresznye")
    return true;
};

console.log(arr.find(cbFindValue));

var cbFindIndex = function(value) {
  if (value === "cseresznye")
    return true;
}

console.log(arr.findIndex(cbFindIndex));

A map metódus segítségével „átmappolhatjuk” a tömbünket, vagyis a tömb összes elemén végiglépked, és az értéken végrehajtja a callback függvényt, majd visszaadja az új tömböt.

var szamok = [1, 2, 3, 4, 5];

var cbMapNegyzet = function(value) {
  return value * value;
};

var negyzet = szamok.map(cbMapNegyzet);

negyzet.forEach(function(e){
  console.log(e);
})

Az entries metódus egy iterátort ad vissza. Az iterátor segítségével végiglépkedhetünk a tömb elemein.

var szamok = [1, 2, 3, 4, 5];

var iterator = szamok.entries();

for (var e of iterator) {
  console.log(e);
}

Az every metódus szintén végiglépked a tömb elemein, majd mindegyiken végrehajt egy callback függvényt, egy tesztet. Ha az összes elem átment a teszten, akkor true-val, ha nem, akkor false-zal tér vissza.

var szamok = [1, 2, 3, 4, 5];

cbEvery = function(e) {
	// return e < 2 && 4 > e // false
	return e > 0 // true
};

console.log(szamok.every(cbEvery));

 

A hivatalos dokumentációhoz néhány példakód:

Szintaxis: fun.call(thisArg[, arg1[, arg2[, ...]]])

A lenti példában szerepel egy objektum, vagyis kettő (obj1, obj2). Ezek tartalmaznak egy-egy property-t. Jelen esetben műveletet akarunk végrehajtani az objektum tartalmával. Ezt legtöbb esetben úgy tennénk, hogy az objektum prototípusába beleraknánk egy metódust.

Viszont megoldhatjuk call metódus meghívásával. A metódusnak átadjuk paraméterben az objektumunkat, ezzel egy új környezetet (Context) alakítunk ki a függvény számára. Ha ezt nem tennénk meg (null), akkor az alapértelmezett this értéket kapja meg.

A lenti példában 3 különböző hívással mutatom be ezt a alkalmazási módot.

this.z = 100; 

function add(arg1, arg2) {
  console.log("Context: " + this)
  
  this.x = arg1;
  this.y = arg2;
  console.log("Z:" + this.z);
  this.z = 200;
  
  console.log("arg1:" + this.x);
  console.log("arg2:" + this.y);
  console.log("Z:" + this.z);
  
  return this.x + this.y + this.num;
}

var obj1 = {num:10}; var obj2 = {num:11};

console.log("Result: " + add(5, 6));
console.log("Result: " + add.call(null, 5, 6));
console.log("Result: " + add.call(obj1, 5, 6));
console.log("Result: " + add.call(obj2, 5, 6));

Kimenet:

Context: [object Window]
Z:100
arg1:5
arg2:6
Z:200
Result: NaN

Context: [object Window] // null
Z:200 // Itt 100 lenne, ha nem hívtam volna meg előtte a függvényt.
arg1:5
arg2:6
Z:200
Result: NaN // Itt nincs this.num, ezért ne értékelődik ki a kifejezés.

Context: [object Object] // obj1
Z:undefined // Az obj1 környezetben még nem szerepel a Z változó ekkor.
arg1:5
arg2:6
Z:200
Result: 21 // Itt már elérhető a this.num az új környezet miatt.

Context: [object Object] // obj2
Z:undefined
arg1:5
arg2:6
Z:200
Result: 22

A következő példánál egy úgynevezett  self-execution vagy self-invoking anonymous függvényt használok. Ha még nem hallottál volna róla, akkor röviden bemutatom.

Tehát ez egy önmagától lefutó függvény, vagyis a weboldal betöltése után automatikusan lefut. Szintaktikája hasonlít a sima függvénymeghívásához. Lényeges, hogy kerek „()” zárójelek között kell lennie.

(function() {
  // code
}())

Legyen egy példa is:

var i = "Piros";

(function(i) {
	console.log(i + " Alma");
}(i)) // Piros Alma

Látható, hogy a self-invoking függvény paraméterként megkapja az i változót, és a függvénytörzsben lévő anonymous függvény pedig „felhasználja”. Érdekes lehetőségek vannak benne, de most menjünk tovább.

var emberek =  [
  {nev: "Emese", kedvencSzin: "piros", haziKedvenc: "kutya"},
  {nev: "Béla", kedvencSzin: "zöld", haziKedvenc:  "macska"},
  {nev: "Erika", kedvencSzin: "lila", haziKedvenc: "teknős"}
];

for (var i = 0; i < emberek.length; i++) {
  (function(i){
    console.log("Név: " + this.nev + ", kedven szín: " + this.kedvencSzin + ", kedvenc állat: " + this.haziKedvenc);
  }).call(emberek[i])
}

function.call() Talán a fentiek elolvasása után nem kell magyarázat. A függvényen belül a lokális környezet (this) az emberek[i] property-kből érkezik.

Egy példa a prototype metódus hívására.

var obj1 = {num:10};
var stringBemenet = "alma";

function Person() {}

Person.prototype.printSomething = function(strBemenet) {
  return strBemenet + " --- " + this.num;
};

console.log(Person.prototype.printSomething.call(obj1, stringBemenet)); // alma --- 10

 

Mai vizsgálódásom tárgya az Observer vagy magyarosan a Megfigyelő tervezési minta. Nézzük meg pontosan mi is ez? Mit ír róla a wikipedia.

„Az Observer, vagy Megfigyelő minta egy olyan szoftvertervezési minta, melyben egy objektum, melyet alanynak hívunk, listát vezet alárendeltjeiről, akiket megfigyelőknek hívunk és automatikusan értesíti őket bármilyen állapot változásról, többnyire valamely metódusuk meghívásán keresztül. Többnyire elosztott eseménykezelő rendszerek kialakításakor használjuk.” – idézet a wikipedia szócikkéből.

Az Observer minta egy-több (1:N, one-to-many) kapcsolatot alakít ki az objektumok között. Van egy Alanyunk (Subject, Observable), akit megfigyelnek a Megfigyelők (Observer).

Deklarálunk két interface-t.

interface iSubject {
  public function Attach($observer);
  public function Detach($observer);
  public function Notify();
}
interface iObserver {
  public function Update(ConcreteSubject $subject);
}
  • Attach – Hozzáadunk egy Megfigyelőt az Alanyhoz.
  • Detach – Elveszünk egy Megfigyelőt az Alanytól.
  • Notify – Értesítés küldése a Megfigyelőknek

A Megfigyelők az Update() metódus segítségével kérhetnek információkat az Alanytól. Ahogy későbbiekben látjuk ezt majd a Notify() metódus fogja meghívni esetünkben.

class ConcreteSubject implements iSubject {
  private $_subjectState = "";
  private $_observers = array();

  public function Attach($observer) {
    $this->_observers[] = $observer;
  }

  public function Detach($observer) {
    // kód
  }

  public function Notify() {
    foreach ($this->_observers as $obs) {
      $obs->Update($this);
    }
  }

  public function getSubjectState() {
    return $this->_subjectState;
  }

  public function setSubjectState($value) {
    $this->_subjectState = $value;
  }
}
class ConcreteObserver implements iObserver {
  private $_name = "";
  private $_observerState = "";
  
  function __construct($name) {
    $this->_name = $name;
  }

  public function Update(ConcreteSubject $subject) {
    $this->_observerState = $subject->getSubjectState();
    echo "Az " . $this->_name . " megfigyelő új állapota " . $this->_observerState . "." . PHP_EOL;
  }
}

Használatuk.

$s = new ConcreteSubject();

$s->Attach(new ConcreteObserver("A"));

$s->Attach(new ConcreteObserver("B"));

$s->setSubjectState("ABC");
$s->Notify();

$s->setSubjectState("QWE");
$s->Notify();

Kimenet.

Az A megfigyelő új állapota ABC.
Az B megfigyelő új állapota ABC.
Az A megfigyelő új állapota QWE.
Az B megfigyelő új állapota QWE.

forrás

Egyéb példa:

Java – ActionListener

  • button is the Subject
  • MyListener is the Observer
  • actionPerformed() is the equivalent to update()
JButton button = new JButton("Click me!");
  button.addActionListener(new MyListener());
  
  class MyListener implements ActionListener {
     public void actionPerformed(ActionEvent event) {
        ...
     }  
  }

A példát/analógiát a wikibooks-on találtam itt.