[రివ్యూ: క్విజ్ 1]
 [ఆలీ Nahm, Oreoluwa Barbarinsa, లుకాస్ ఫ్రీటస్, రాబ్ బౌడెన్] [హార్వర్డ్ విశ్వవిద్యాలయం]
 [ఈ CS50 ఉంది.] [CS50.TV]
 [లుకాస్ ఫ్రీటస్] ప్రతి ఒక్కరూ స్వాగతం. ఈ క్విజ్ 1 కోసం సమీక్ష ఉంది.
 ఒక డిస్క్లైమర్ వంటి, ఈ ఉపన్యాసం -, మేము కవర్ చేయడానికి ప్రయత్నించండి చూడాలని
 సాధ్యం, కానీ విషయాలతో అని కాదు అని
 మేము క్విజ్ 1 ఉండగల విషయాలు అన్ని కవర్ చూడాలని.
 కాబట్టి మీరు కూడా ఒక ఉపన్యాసం వద్ద లుక్, విభాగాలు, మీరు ప్రతిదీ పడుతుంది చేయండి.
 క్విజ్ 1 బుధవారం, తదుపరి బుధవారం అన్నారు.
 కాబట్టి అధ్యయనం చేయండి. ఇది మొదటి క్విజ్ వంటి, చాలా చక్కని, చేస్తాడు
 దాని ఫార్మాట్ గురించి, కానీ బహుశా చాలా కష్టం చేస్తాడు.
 నేను 50 తీసుకున్నాడు కనీసం గత ఏడాది, నేను చాలా కష్టం భావించారు.
 కాబట్టి చాలా అధ్యయనం.
 

నేను డేటా నిర్మాణాలు కవర్ వెళుతున్న మరియు హఫ్ఫ్మన్ కోడింగ్.
 ఈ, ప్రజలు చాలా క్లిష్టమైన భావిస్తున్న విషయం
 కానీ నేను వీలైనంత ఇది సులభంగా ప్రయత్నించండి వెళుతున్న.
 అన్ని మొదటి, మేము మీరు అబ్బాయిలు క్విజ్ 1 కోసం తెలుసుకోవాలంటే ఉంది
 నేను ప్రస్తుత వెళుతున్న డేటా నిర్మాణాలు ప్రతి సంభావిత వివరణలు అర్థం.
 మీరు లేదు అర్థం వాస్తవానికి
 మీ క్విజ్ 1 లో ఒక హాష్ పట్టిక అమలు.
 మేము మీరు మొత్తం హాష్ పట్టిక అమలు చేయకూడదని; బహుశా మేము ప్రయత్నిస్తాము
 మీరు కొన్ని విధులు అమలు చేయడానికి,
 అత్యంత సాధారణ శస్త్ర, కాని మేము మీరు ప్రతిదీ అమలు చేయడానికి వెళ్ళి లేదు.
 కాబట్టి మీరు ప్రతి డేటా నిర్మాణం వెనుక భావన అర్థం ఆ ముఖ్యం
 మరియు మీరు C లో కోడ్ చేయగల,
 వారు ప్రతి చర్చించి ఉండవచ్చు కేవలం అత్యంత సాధారణ శస్త్ర.
 మరియు, గమనికలు మరియు structs సమీక్షించి చెయ్యగలరు
 వారు ఈ డేటా నిర్మాణాలు చాలా కనిపిస్తాయి ఎందుకంటే.
 

చాట్. లింక్ జాబితాలు నిజానికి శ్రేణుల పోలి ఉంటాయి,
 కానీ ఒక లింక్ జాబితా మరియు వ్యూహం మధ్య వ్యత్యాసం,
 మొదటి అన్ని యొక్క,, అనుబంధ జాబితా చాలా సరళమైన పరిమాణం కలిగి ఉంది
 శ్రేణుల లో మీరు అమరికకు ఒక పెద్ద పరిమాణం ఎంచుకోవడానికి గాని కలిగి,
 కాబట్టి మీరు, మీరు, ఆ శ్రేణి లో అన్ని మీ డేటాను నిల్వ చెయ్యడానికి వెళుతున్న తెలుసు
 లేదా మీరు శ్రేణి యొక్క సరళమైన పొడవు కలిగి malloc ఉపయోగించాలి.
 లింక్ జాబితాలు లో ఇది కేవలం మరింత అంశాలు పొందడానికి చాలా సులభం,
 లింక్ జాబితాలో మరిన్ని అంశాలు ఉంచారు లేదా అంశాలను తొలగించు.
 మరియు వాస్తవానికి, మీరు లింక్ జాబితా వేరు చేయకూడదని ఉంటే,
 శోధన మరియు స్థిరమైన సమయంలో అంశాలు తొలగించవచ్చు,
 కాబట్టి O (1) సమయం, కాబట్టి అది చాలా సౌకర్యవంతంగా ఉంది.
 మీరు కేవలం, నోడ్స్ ఎల్లప్పుడూ malloc గుర్తుంచుకోండి జాగ్రత్తగా మరియు ఉచిత ఉండాలి
 మీరు లేకపోతే, మీరు మెమరీ లీకేజ్ ఉంటుంది కనుక.
 కాబట్టి లింక్ జాబితాలు - ఒక నోడ్ యొక్క నిర్వచనం కేవలం మేము అక్కడే ఏమి వంటి ఉంది.
 నేను p-సెట్స్, కానీ మీరు మీకు కావలసిన డేటా నిల్వ చేయవచ్చు.
 మీరు ఒక స్ట్రింగ్ నిల్వ అనుకుంటే కాబట్టి, అది మంచిది.
 మీరు ఒక struct నిల్వ చేయాలనుకుంటే, మీరు కావలసిన,, ఒక డబుల్ మంచిది.
 కాబట్టి ఈ p-సెట్స్.
 మరియు మీరు తదుపరి నోడ్ ఒక పాయింటర్.
 కాబట్టి, ప్రాథమికంగా, ఒక అనుబంధ జాబితా కొన్ని డేటా ఉంది, తరువాత ఇది తదుపరి నోడ్ పాయింట్లు.
 ఇది లింక్ జాబితాలో చివరి మూలకం, అది శూన్య సూచించడానికి జరగబోతోంది.
 కాబట్టి ఈ అనుబంధ జాబితా యొక్క ఒక ఉదాహరణ.
 

సరే, ఇప్పుడు నేను ఒక అనుబంధ జాబితా ఒక మూలకం ఇన్సర్ట్ అనుకుంటే యొక్క మేము చెయ్యాలి చూద్దాం.
 మొదటి, ఒక ఫంక్షన్ చొప్పించు రకం శూన్యము ఉంటుంది
 నేను దేన్నీ వద్దు ఎందుకంటే.
 నేను ఒక వాదన వంటి ఒక Int తీసుకుని వెళుతున్న,
 నేను ఇన్సర్ట్ ఏమి తెలుసు అనుకుంటున్నారా ఎందుకంటే.
 నేను చెయ్యాలి మొదటి విషయం ఏమిటి? Well, నేను newnode న malloc ఉండాలి,
 కాబట్టి మొదటి లైన్.
 నేను ఒక అనుబంధ జాబితా లో ఉంచాలి ఒక కొత్త నోడ్ సృష్టించడం నేను.
 నేను ఏమి చెయ్యగలరు? బాగా, మేము తెలిసిన లింక్ జాబితాలు మా అమలు లో
 తరగతి, మేము ఎల్లప్పుడూ ఒక ప్రపంచ వేరియబుల్ వంటి తల పెట్టి.
 కాబట్టి మనం చేయవచ్చు తల మార్చండి ఉంది.
 నేను ఈ కొత్త నోడ్ కొత్త తల చేయవచ్చు,
 మరియు అది మునుపటి తల సూచించడానికి జరగబోతోంది.
 మేము ఆ చేయవచ్చు? నేను చేయాల్సిందల్లా మొదటి విషయం
 , విలువకు కొత్త నోడ్ లో 'n' మార్పు
 ఫంక్షన్ ఆమోదించింది ఇది.
 అప్పుడు newnode నెక్స్ట్ తల అన్నారు.
 తల newnode అన్నారు. కాబట్టి ఇది అందంగా సులభం.
 ఒక నోడ్ తొలగించడం, మేము లాగా చేయవచ్చు -
 మేము ఆ చేయగలిగే విధంగా చెప్పబడినది,
 సరే, నేను తొలగించడానికి కోరుకుంటే, ఉదాహరణకు, 3,
 నేను చేయగలిగే కేవలం మునుపటి నోడ్ స్థానం
 3 యొక్క తదుపరి నోడ్.
 నేను ఆ వంటి ఏదో ఒకటి అని.
 కానీ చేయడం సమస్య ఏమిటి?
 నేను మెమొరీ లీక్ ఉన్నాయి, నేను ఇకపై సంఖ్య 3 యాక్సెస్ లేదు.
 ఆ సమస్య నేను ఆ నోడ్ విడిపించేందుకు చెయ్యడానికి వెళ్ళడం లేదు అని ఉంది.
 నేను మెమరీ లీకేజీ (అపారదర్శక) నాకు ద్వేషం అన్నారు వెళుతున్న.
 బదులుగా ఆ చేయడం వలన, నేను బహుశా తాత్కాలిక పాయింటర్ కలిగి ఉండాలి.
 నేను తాత్కాలిక చాలు. ఇది నేను తొలగించదలిచారా నోడ్ సూచించడానికి అన్నారు.
 ఆపై నేను తదుపరి నోడ్ బిందువు మునుపటి నోడ్స్ తరలించవచ్చు
 నేను తొలగించదలిచారా నోడ్ యొక్క.
 చివరకు, నేను చేస్తాము.
 నేను అక్కడే సృష్టించిన పాయింటర్ విడిపించేందుకు ఉందా?
 నేను, కనుక లేదు -
 తేడా ఈ నోడ్ malloc ఉపయోగించి సృష్టించిన ఉంది,
 ఈ ఒక కేవలం స్టాక్ లో ఒక నల్ స్విచ్ ప్రకటించారు కాబట్టి ఇది, కుప్ప లో ఉంది. ఎప్పుడు లేదు.
 సరే >>. కాబట్టి ఇప్పుడు యొక్క స్టాక్స్ గురించి మాట్లాడటానికి వీలు.
 స్టాక్స్ అందంగా సూటిగా ఉన్నాయి.
 మేము శ్రేణుల ఉపయోగించి తరగతి లో స్టాక్స్ మరియు క్యూలు చేశాడు,
 కానీ మీరు తెలిసిన ఉండాలి - కేవలం తెలుసుకోవాలి
 మీరు కూడా అదే అనుసంధాన జాబితాలు ఉపయోగించి క్యూలు లో స్టాక్స్ చేసే.
 మీరు వ్యూహం కలిగి చేస్తే, ఏమి ఒక స్టాక్ ఉంటుంది?
 ఒక స్టాక్, మొదటి, ఒక పరిమాణం కలిగి ఉంటుంది.
 మీరు ఇప్పుడే కలిగి స్టాక్ పరిమాణం నిల్వ ఉంటుంది.
 మరియు మీరు, సంఖ్యల ఈ సందర్భంలో, వ్యూహం వుంటుంది
 కానీ మీరు కోరుకుంటే, అది వ్యూహం ఉంటుంది
 తంత్రుల struct యొక్క వ్యూహం, మీరు నిల్వ మీరు ఏదైనా.
 స్టాక్ గురించి: ఒక స్టాక్ మరియు అనుబంధ జాబితా మధ్య వ్యత్యాసం
 స్టాక్ మీరు మాత్రమే స్టాక్ లో ఉంచబడినది చివరి మూలకం ప్రాప్తి ఉంది.
 అది మొదటి, గత లో అని.
 మీరు ట్రేలు ఒక స్టాక్ కలిగి వలె,
 మీరు స్టాక్ పైన ఒక ట్రే ఉంచితే,
 మీరు ఇతర ట్రేలు యాక్సెస్ మొదటి ట్రే తొలగించాలి.
 ఇది స్టాక్లతో అదే విషయం.
 నేను, ఉదాహరణకు, ఒక స్టాక్ ఒక మూలకం జోడించడానికి అనుకుంటే, నేను ఏమి చెయ్యాలి?
 ఇది పుష్ అనే, మరియు ఇది మంచి సూటిగా వార్తలు అనిపిస్తుంది.
 మీరు చేయాల్సిందల్లా మొదటి విషయం చెక్ ఉంటే స్టాక్ పరిమాణం
 ఎక్కువ లేదా స్టాక్ సామర్థ్యం సమానం కాదు.
 మీరు ఇప్పటికే పూర్తి సామర్థ్యం ఉంటే, మీరు వేరే ఏదైనా చేర్చలేరు ఎందుకంటే.
 కాదు ఆపై, మీరు స్టాక్కు మూలకం చేర్చుకోవాలి.
 చివరకు, పరిమాణం పెంచడం. కనుక ఇది చాలా సూటిగా ఉంది.
 కాబట్టి నేను సంఖ్య 2 జోడించండి.
 నేను పాప్ అనుకుంటే, ఇది నేను తొలగించాలని అర్థం
 జోడించారు మరియు మూలకం యొక్క విలువ తిరిగి ఆ గత మూలకం,
 నేను తనిఖీ మొదటి విషయం స్టాక్ ఖాళీ కాదు.
 అది ఖాళీ ఉంటే, నేను దేన్నీ ఎందుకంటే.
 ఆ సందర్భంలో, నేను -1 తిరిగి నేను.
 లేకపోతే, నేను స్పెక్ యొక్క పరిమాణం తరుగుదల వెళుతున్న,
 మరియు సంఖ్యలు (s.size) తిరిగి.
 నేను పరిమాణం తరుగుదల ఆపై s.size తిరిగి లేదు?
 ఈ సందర్భంలో, స్పెక్ పరిమాణం 4 ఉంది, ఎందుకంటే,
 మరియు నేను నాల్గవ తిరిగి కావలసిన, కుడి?
 కానీ నాల్గవ సూచిక ఏమిటి? మూడు.
 నేను పరిమాణం కాబట్టి - 3 అన్నారు, నేను (s.size) s.numbers తిరిగి
 ఇది 3 ఎందుకంటే. కనుక ఇది కేవలం సూచిక ఉంది.
 

ఇప్పుడు వరుసలో. క్యూలు చాలా చక్కని ఇదే ఉంటాయి.
 మాత్రమే తేడా, బదులుగా చివరి లో కలిగి, మొదటి ముగిసింది
 మీరు మొదటి, మొదటి కలిగి.
 మీరు ఒక కచేరీ వెళ్ళడానికి వేచి బహుశా ఉంటే,
 మీరు బదులుగా ఒక క్యూ ఒక స్టాక్ కలిగి ఉంటే మీరు సంతోషంగా ఉండదు.
 వచ్చిన చివరి వ్యక్తి కార్యక్రమం ప్రవేశించిన మొదటి వ్యక్తి ఉంటుంది.
 మీరు బహుశా సంతోషంగా ఉండదు.
 క్యూ లో, లో పొందడానికి మొదటి వ్యక్తి కూడా అవుట్ మొదటి వ్యక్తి.
 కాబట్టి ఒక క్యూ నిర్వచనం, అర్రే పరిమాణం కలిగి పాటు,
 మీరు కూడా స్టాక్ అధిపతి సూచిక ఇది తల, కలిగి.
 ప్రస్తుతం మొదటి మూలకం కాబట్టి.
 ఎన్క్యూ స్టాక్లకు పుష్ అదే విషయం.
 మీరు చాలా సరళ ఉంటే, మీరు కేవలం చెబుతారు,
 నేను పుష్ చేసినట్టే అలాగే, నేను అదే విషయం చేయవచ్చు.
 ఇది తలదన్నిన లేకుంటే నేను తనిఖీ చేయవచ్చు.
 అది ఉంటే, నేను లేకపోతే నేను కొత్త విలువ ఎగుమతి చేయవచ్చు, తప్పుడు తిరిగి
 ఆపై పరిమాణం పెంచడం.
 కానీ ఎందుకు ఈ తప్పు?
 ఈ ఉదాహరణ చూద్దాం.
 నేను stuff ఒక సమూహం ఎన్క్యూ ప్రయత్నిస్తున్నాను,
 ఆపై నేను dequeue మరియు ఎన్క్యూ వెళుతున్న.
 అక్కడ ఆదేశాల చాలా, కానీ ఇది చాలా సులభం.
 నేను 5 ఎన్క్యూ, కాబట్టి 5 జోడించండి మాత్రం, ఆపై 7, వెబ్
 1, 4, 6, మరియు నేను ఏదో dequeue మీరు,
 ఇది నేను మొదటి మూలకం తొలగించు వెళుతున్న అర్థం.
 కాబట్టి నేను సంఖ్య 3 తొలగించు వెళుతున్న?
 మొదటి మూలకం. సరే.
 నేను ఏదో ఎన్క్యూ ప్రయత్నించినట్లయితే ఏమౌతుంది అన్నారు?
 నా అమలు ప్రకారం,
 నేను ఇండెక్స్ q.size తరువాత సంఖ్య ఉంచాలి వెళుతున్నాను.
 ఈ సందర్భంలో, పరిమాణం 8 ఉంది,
 కాబట్టి ఇండెక్స్ 8 గత స్థానంలో ఇక్కడే ఉంటుంది.
 నేను ఇక్కడే 1 ఎన్క్యూ ప్రయత్నించండి ఉంటే, నేను గత స్థానం కొట్టివేతలు అవుతుంది
 పూర్తిగా తప్పు సంఖ్య 1, కు.
 నేను చేయాలనుకుంటున్నారా చుట్టూ మరియు మొదటి స్థానం వెళ్ళండి ఉంది.
 బహుశా మీరు బాగా, నేను చెక్ ఉంటుంది చెబుతా
 నిజానికి అక్కడ ఏదో ఉంచవచ్చు ఉంటే.
 లేకపోతే, నేను, OH, కొత్త పూర్తి సామర్థ్యం, ​​చెప్పటానికి
 నిజానికి సామర్థ్యం - 1, మరియు మీరు అక్కడ ఒక మూలకం కాదు.
 కానీ సమస్య ఏమిటి? సమస్య అని నేను ఇక్కడే ప్రతిదీ dequeue ఉంటే
 ఆపై నేను ఏదో జోడించడానికి ప్రయత్నించండి, ఇది కేవలం చెబుతారు,
 బాగా, మీరు 0 ఇది పూర్తి సామర్థ్యం వద్ద ఉన్నాయి.
 మీ క్యూ వెళ్లిపోయిన.
 మీరు చుట్టూ ఉంటుంది, మరియు చుట్టూ చుట్టడం ఒక మార్గం
 మీరు అధ్బుతమైన మరియు ఇతర psets నేర్చుకున్న అబ్బాయిలు mod ఉపయోగించి ఆ.
 మీరు q.size + q.head అని ఎందుకు అర్థం ఇంట్లో ప్రయత్నించవచ్చు
 mod సామర్థ్యం, ​​కానీ మీరు ఇక్కడ తనిఖీ ఉంటే,
 మేము ఆ పని చూడగలరు.
 గత ఉదాహరణలో, 8 q.size ఉంది
 ఇది ఇక్కడ శ్రేణి యొక్క ఈ స్థానం ఎందుకంటే మరియు తల, 1 ఉంది.
 కనుక ఇది + 1 8, 9 ఉంటుంది. మోడ్ సామర్థ్యం 9 0 ఉంటుంది.
 ఇది ఇండెక్స్ 0 కు చేరుతుంది. మేము స్థానం ఉంటాము. తరువాత ఇంట్లో క్యూ ప్రయత్నించండి.
 కొన్ని ముఖ్యమైన విషయాలు: ఒక స్టాక్ మరియు ఒక క్యూ మధ్య వ్యత్యాసం అర్థం ప్రయత్నించండి.
 ఇంటిలో, ఎన్క్యూ, dequeue, పుష్ మరియు పాప్ అమలు చాలా బాగా ప్రయత్నించవచ్చు.
 మీరు వాటిని ప్రతి ఉపయోగించడానికి ఎప్పుడు మరియు అర్థం.
 

కాబట్టి యొక్క తప్పనిసరిగా కొంత తో 10 సెకన్ల బాస్.
 ఇప్పుడు యొక్క తిరిగి డేటా నిర్మాణాలు వినుడు.
 పట్టికలు హాష్. మంది హాష్ పట్టికలు భయపడుతుంటారు.
 సమస్య 6 సెట్ లో, అక్షర తనిఖీ.
 హాష్ పట్టికలు మరియు ప్రయత్నాలు, ప్రజలు చాలా వాటిని భయపడతారు.
 వారు అర్థం చాలా కష్టం భావిస్తున్నాను. అవును?
 [రాబ్ బౌడెన్] సమస్య 5 సెట్. 

సమస్య అవును, 5 సెట్. ధన్యవాదాలు రాబ్.
 అవును. ఆరు హఫ్ n 'పఫ్, అవును ఉంది.
 సమస్య అక్షర తనిఖీ 5 సెట్, మరియు మీరు ఒక హాష్ పట్టిక లేదా ఒక ప్రయత్నించండి వుపయోగించటానికి వచ్చింది.
 మంది వారు అర్థం సూపర్ హార్డ్ అనుమానించి, కానీ వారు నిజానికి చాలా సాధారణ ఉన్నాము.
 ఒక హాష్ పట్టిక ప్రధానంగా, ఏమిటి? ఒక హాష్ పట్టిక లింక్ జాబితాలు యొక్క వ్యూహం ఉంది.
 వ్యూహం మరియు ఒక హాష్ పట్టిక మధ్య తేడా
 హాష్ పట్టిక లో మీరు హాష్ విధి అని ఏదో ఉంటుంది.
 హాష్ విధి ఏమిటి?
 మీరు అబ్బాయిలు ఇక్కడ చదువుకోవచ్చు ఉంటే నాకు తెలీదు.
 సరే ఒక ఉదాహరణ.
 కాబట్టి మీరు 31 అంశాలతో వ్యూహం కలిగి చూడగలరు.
 మరియు మేము ఒక హాష్ పట్టిక లో ఒక హాష్ ఫంక్షన్ను ఉంది
 ఒక కీ అనువదించు అన్నారు, ప్రతి ఒక ఇండెక్స్ Int.
 , ఉదాహరణకు, నేను B. హారిసన్ కోసం ఎంచుకోండి అనుకుంటే,
 నా హాష్ విధులు లో B. హారిసన్ ఉంచుతాడు,
 హాష్ ఫంక్షన్ 24 తిరిగి.
 కాబట్టి నేను 24 లో B. హారిసన్ నిల్వ మీరు తెలుసు.
 కాబట్టి ఆ వ్యూహం కలిగి మరియు ఒక హాష్ పట్టిక కలిగి మధ్య తేడా ఉంది.
 హాష్ పట్టిక మీరు చెప్పడం అన్నారు ఒక ఫంక్షన్ ఉంటుంది
 మీరు నిల్వ కావలసిన డేటా నిల్వ.
 కాబట్టి మేము, మీరు హాష్ విధి కోసం చూడవచ్చు
 ఆ డొమెస్టిక్ మరియు బాగా పంపిణీ ఉంది.
 మీరు ఇక్కడ చూడవచ్చు, మీరు నేను స్టోర్ కోరుకున్నాడు డేటా చాలా నిజానికి 19 సంపాదించెను
 బదులుగా అన్ని ఉండేవారని ఇది 31 మరియు 30 మరియు 29, ఉపయోగించి.
 నేను ఉపయోగించిన హాష్ విధి చాలా బాగా కుడి.
 మేము బాగా పంపిణీ చెప్పినప్పుడు, మేము కలిగి కావలసిన అర్థం
 సుమారు, కనీసం 1 లేదా ప్రతి 2 -
 వంటి, శ్రేణుల లో సూచీలు ప్రతి 1 లేదా 2 ఒక తేడా.
 మీరు, సుమారు, వ్యూహం ప్రతి లింక్ జాబితాలో అంశాల అదే నెంబర్ కావాలి.
 మరియు అది, హాష్ పట్టిక లో చెల్లదు హాష్ పట్టికలు వంటి వీక్షణ ఉంటే తనిఖీ సులభం.
 

అప్పుడు చెట్లు. ఈ ఒక వృక్షం.
 కంప్యూటర్ సైన్స్ లో చెట్లు కారణం డౌన్ పైకి ఉంటాయి.
 కాబట్టి ఇక్కడ మీరు చెట్టు యొక్క మూల మరియు ఆకులు కలిగి.
 మీరు తల్లిదండ్రులు మరియు పిల్లల నామావళి తెలుసుకోవాలి.
 ప్రతి నోడ్ మాతృ క్రింద ఉండే నోడ్స్ ఉండే తన పిల్లలు, ఉంది.
 కాబట్టి, ఉదాహరణకు, 2, అక్కడే 3 కోసం మరియు ఇతర పిల్లల కోసం మాతృ అన్నారు
 3 1 కోసం మాతృ మరియు ఉన్నాయి ఇతర పిల్లలు అన్నారు అయితే.
 మరియు 1 అందువలన న 3 పిల్లలను అన్నారు, మరియు.
 మేము, మరింత ఆసక్తికరంగా, ఒక బైనరీ శోధన చెట్టు అనే
 దీనిలో ఒక నోడ్ యొక్క కుడి అన్ని విలువలు
 ఇక్కడే, కుడి ఉంటాయని - కుడి,
 x = ఎక్కువ ఉంటాయని.
 కుడి న, నేను ఇక్కడే సంఖ్య 5 కలిగి ఉంటే, అన్ని అంశాలు
 5 కంటే ఎక్కువ మాత్రం, మరియు ఎడమ ఉన్నాయి
 అన్ని అంశాలు 5 కంటే తక్కువ ఉంటాయని.
 ఎందుకు ఈ ఉపయోగపడుతుంది?
 Well, నేను సంఖ్య 7 ఇక్కడ ఉంటే తనిఖీ అనుకుంటే, ఉదాహరణకు,
 నేను మొదటి 5 వెళ్లి నేను చూడండి వెళుతున్న, 5 కంటే 7 ఎక్కువ లేదా తక్కువ ఉంది?
 ఇది ఎక్కువ, కనుక నేను చెట్టు యొక్క కుడి ఉండాలి చేస్తాడు తెలుసు.
 నేను చూడండి తక్కువ అంశాలు ఉన్నాయి.
 ఒక బైనరీ శోధన చెట్టు, నోడ్ అమలులో, నేను, డేటా కలిగి వెళుతున్న
 కాబట్టి Int n; మీరు ఒక స్ట్రింగ్ కలిగి
 లేదా మీరు కోరుకున్న ఏదైనా.
 మీరు ఎక్కువ ఏమిటి నిర్వచించు న జాగ్రత్తగా ఉండాలి, తక్కువ ఏమిటి.
 కాబట్టి మీరు తీగలను కలిగి ఉంటే, ఉదాహరణకు, మీరు నిర్వచించడం
 కుడివైపు సంగతులన్నీ పెద్ద పొడవు కలిగి వెళ్ళే,
 ఎడమ తక్కువ పొడవు పొందబోతున్నారు, కాబట్టి అది మీకు నిజంగా ఉంది.
 

నేను జూలకంటి కోసం కనుగొనేందుకు అమలు?
 మేము మొదటి విషయం రూట్ NULL ఉంటే తనిఖీ ఉంది.
 ఇది NULL, అది విషయం కాదు అర్థం
 మీరు కూడా ఒక చెట్టు, కుడి లేదు ఎందుకంటే?
 నేను తప్పుడు తిరిగి.
 లేకపోతే, నేను సంఖ్య ఎక్కువ ఉంటే తనిఖీ వెళుతున్న
 రూటు విలువ కంటే.
 నేను కుడి మూలకం కనుగొనేందుకు ప్రయత్నించండి వెళుతున్న
 చెట్టు.
 మీరు నేను ఇక్కడ సూత్రం ఉపయోగించి వెబ్ చూడండి.
 ఇది తక్కువ ఉంటే, నేను ఎడమ చూడండి వెళుతున్న.
 చివరకు, లేకపోతే, అది ఎక్కువ తక్కువ లేదా కాదు,
 ఇది దానిని విలువ కూడా అర్థం.
 కాబట్టి నేను నిజమైన తిరిగి.
 మీరు నేను ఉంటే, ఉంటే, ఉంటే ఉపయోగించిన ఇక్కడ చూడగలరు.
 మరియు, గుర్తు క్విజ్ 0 లో, మేము,, ఉంటే, ఉంటే ఉందని ఒక సమస్య వచ్చింది
 మరియు మీరు అసమర్థతపై కనుగొనేందుకు నిర్ణయించుకున్నాయి,
 మరియు అసమర్థతపై మీరు అనుభవిస్తున్నారు. మీరు అయితే వేరే, ఉంటే, ఉంటే ఉపయోగిస్తారు, మరియు మిగతా వుండాలి.
 ఉంటే మిగిలిన ఉంటే మిగిలిన ఇక్కడ కాబట్టి, నేను వేరే ఉపయోగించాలి?
 మళ్ళీ చేయాలి - అవును?
 [స్టూడెంట్ మాట్లాడే, వినబడని]
 ఆ ఖచ్చితమైన ఉంది. కాబట్టి ఆమె, అది పట్టింపు లేదు మాట్లాడుతూ
 కనుక మేము ముందు ఉందని అసమర్థతపై
 అని, కొన్ని పరిస్థితి సంతృప్తి ఉండవచ్చు ఉంటే,
 కాబట్టి మీరు ఒక చర్య, కానీ మీరు ఇతర పరిస్థితులు అన్ని తనిఖీ ఉండేవి.
 కానీ ఈ సందర్భంలో, అది వెంటనే తిరిగి, కాబట్టి అది పట్టింపు లేదు.
 కాబట్టి మీరు అయితే వేరే ఉపయోగించడానికి లేదు.
 

చివరకు, యొక్క ప్రయత్నాలు మాట్లాడటానికి వీలు,
 ఇది అందరి ఇష్టమైన ఉంది.
 ఒక ప్రయత్నించండి శ్రేణుల యొక్క ఒక వృక్షం.
 ఇది విలువలు చూసేందుకు చాలా వేగమైనది, కానీ మెమరీ చాలా ఉపయోగిస్తుంది.
 మరియు అది పదాలు ఫిల్టర్ సాధారణంగా ఉంది, కాబట్టి మీరు
 మీ ఫోన్ లో ఒక ఫోన్ బుక్ వంటి, ఉదాహరణకు, నేను తెలియదు, అమలుచెయ్యాలని
 మరియు మీరు B టైప్ చెయ్యడానికి మీరు
 మరియు కేవలం B. కలిగి వ్యక్తుల పేర్లు కలిగి
 ఇది ఉదాహరణకు, ఒక ప్రయత్నించండి ఉపయోగించి ఆ అమలు చాలా సులభం.
 ఎలా మీరు ఒక ప్రయత్నించండి ఒక నోడ్ నిర్ధారిస్తారు?
 మీరు is_word కావడం ఒక bool కలిగి.
 ఆ, ఆ నోడ్ ముందు అన్ని అక్షరాలు ఉపయోగించి ఆ సూచిస్తుంది
 మీరు ఒక పదము సాధించారు,
 ఆపై మీరు కణుపులకు గమనికలు యొక్క వ్యూహం ఉంటుంది.
 మీరు మేము ఒక పేరెంట్ ల శ్రేణి, కాబట్టి నోడ్ * శ్రేణి కలిగి చూడగలరు? అవును?
 కాబట్టి యొక్క ఆ పని ఎలా చూద్దాం. స్పెల్ చెక్ కోసం,
 మేము 27 అంశాల వ్యూహం కలిగి,
 మేము అన్ని అక్షరాలు ప్లస్ అపాస్టిఫియర్ ఎందుకంటే.
 నేను బోర్డు వ్రాయండి చెయ్యడానికి కావలసిన ఎందుకంటే ఇక్కడ ముందు నేను 2 ఉపయోగించడానికి వెళుతున్న.
 సరే. కాబట్టి ఈ ఒక ప్రయత్నించండి యొక్క ఒక ఉదాహరణ.
 నేను మొదటి నోడ్ నిర్వచించే ఉంటే, నేను 2 అంశాల వ్యూహం ఉంటుంది
 శూన్య 2 గమనికలు ఉన్నాయి, కాబట్టి నేను 'ఒక' మరియు 'బి' పెట్టే.
 నేను is_word అని ఒక bool కలిగి వెళుతున్న.
 ఇది మొదటి ఒక కోసం తప్పుడు చేస్తాడు,
 కేవలం, ఎందుకంటే ముందు మీరు ఏ అక్షరాలు లేదు.
 కాబట్టి ఒక ఖాళీ పదం ఒక పదం కాదు. కనుక ఇది తప్పు.
 నేను ఈ నిఘంటువు 'ఒక' జోడించాలనుకుంటే, నేను వుంటుంది?
 నేను 'ఒక' కోసం ఒక కొత్త నోడ్ malloc వుంటుంది,
 ఆపై నిజమైన దాని పదం జోడించండి.
 కనుక ఇది కేవలం 'ఒక' నిజమే అన్నారు వలన ఆ సూచిస్తుంది. సమంజసం?
 నేను 'బా' జోడించాలనుకుంటే అప్పుడు, నేను 'బి' కోసం malloc 1 ఉంటుంది,
 ఆపై నేను, తప్పుకు బూలియన్ ఏర్పాటు వెళుతున్న
 ద్వారా 'బి' ఒక పదం కాదు ఎందుకంటే.
 అప్పుడు నేను మరొక 'ఒక' కోసం ఒకటి, 'బా' malloc వెళుతున్న,
 ఆపై నేను నిజమైన ఒక పదం ఏర్పాటు వెళుతున్న.
 'బా' ఒక పదం ఎందుకంటే.
 నేను చూడటానికి కావాలా తర్వాత 'బి' ఈ నిఘంటువు ఉంటే
 నేను మొదటి ఒకటి, 'బి' వెళ్ళవచ్చు. నేను డౌన్ వెళ్లి, నేను పదం చూడండి, మరియు అది తప్పుడు చెప్పారు.
 కనుక ఇది ఒక పదం కాదు. నేను 'బా' తనిఖీ చేయాలనుకుంటే,
 నేను మొదటి ఒక, 'బి' వెళ్ళండి, ఆపై 'ఒక' వెళ్లి, నేను నిజమైన చూడండి, కాబట్టి ఇది ఒక పదం. సమంజసం?
 మంది ప్రయత్నాలు అయోమయంలో పొందడానికి. ఏ?
 

చివరగా, హఫ్ఫ్మన్ కోడింగ్. హఫ్ఫ్మన్ కోడింగ్ చాలా ఉపయోగకరంగా ఉంది
 మెమరీ సేవ్ మరియు టెక్స్ట్ ఫైళ్లు కుదించుము,
 కనుక మీరు ఉదాహరణకు, 'ఒక' మరియు 'ఇ' ఉపయోగించడానికి సార్లు చాలా,
 మీరు అబ్బాయిలు చాలా 'q' లేదా 'z' ఉపయోగిస్తే మీ పత్రాలు లో, కానీ నేను తెలియదు.
 ప్రతి పాత్ర కోసం కేవలం 1 బైట్ కలిగి,
 ప్రతి - మేము ASCII పట్టిక కలిగి 256 అక్షరాలు చాలా ఆశించకూడదు,
 మీరు మరింత ఉపయోగించే కొన్ని అక్షరాలు ఉన్నాయి కనుక,
 కాబట్టి మీరు విషయాలే తక్కువ మెమరీ ఉపయోగించాలి.
 నేను హఫ్ఫ్మన్ కోడింగ్ ఉపయోగించగలను?
 మేము ఒక హఫ్ఫ్మన్ చెట్టు చేయాల్సిందల్లా.
  ఒక హఫ్ఫ్మన్ చెట్టు నోడ్స్ ఉంది
 లేఖ, 'సి', 'బి', 'ఒక', వంటి అన్నారు చిహ్నంగా కలిగి,
 మీరు చర్యలన్నీ అక్షరం, పదం టెక్స్ట్ కనిపించే ఫ్రీక్వెన్సీ అని ఒక ఫ్రీక్వెన్సీ,
 మీరు, కోసం హఫ్ఫ్మన్ చెట్టు జరిగింది అని
 ఆపై హఫ్ఫ్మన్ చెట్టు యొక్క ఎడమ సూచించడానికి అన్నారు ఒక నోడ్
 మరియు కుడి సూచించడానికి అన్నారు మరొక నోడ్. అవును ఇష్టం.
 ఎలా మీరు ఒక హఫ్ఫ్మన్ చెట్టు నిర్మించడానికి చెయ్యాలి?
 మీరు తక్కువ పౌనః ఆ 2 నోడ్స్ ఎంచుకోండి చూడాలని.
 మీరు ఒక వ్యక్తి మీరు 2 నోడ్స్ ఎంచుకోండి చూడాలని
 అలాగే అత్యల్ప ASCII విలువలు కలిగి.
 అప్పుడు మీరు ఆ 2 నోడ్స్ నుండి కొత్త చెట్టు సృష్టించడానికి చూడాలని
 ఆ పేరెంట్ నోడ్ లో కలిపి ఫ్రీక్వెన్సీ కలిగి అన్నారు.
 ఆపై మీరు అడవి నుండి 2 పిల్లలు తొలగించడానికి చూడాలని
 మరియు మాతృ వాటిని భర్తీ.
 మరియు మీరు మాత్రమే అడవిలో 1 చెట్టు వరకు ఆ పునరావృతం చూడాలని.
 కాబట్టి యొక్క మీరు ZAMYLA కోసం ఒక హఫ్ఫ్మన్ చెట్టు అని ఎలా చూద్దాం.
 మీరు అన్ని అక్షరాలు 'ఒక' తప్ప ఫ్రీక్వెన్సీ 1 కలిగి ఇక్కడ చూడగలరు; ఫ్రీక్వెన్సీ 2 కలిగి.
 కాబట్టి నేను ASCII విలువ మరియు ఫ్రీక్వెన్సీ క్రమంలో చాలు అన్ని అక్షరాలు కోసం నోడ్స్ రూపొందించినవారు.
 నేను మొదటి చెట్టు సృష్టించడానికి అనుకుంటే, ఇది 'L' మరియు 'M' తో ఉంటుంది.
 కాబట్టి యిదిగో. జత యొక్క ఫ్రీక్వెన్సీ 2 ఉంటుంది
 అది + 1 1 ఎందుకంటే, అప్పుడు తక్కువ పౌనః తదుపరి 2 'Y' మరియు 'Z' ఉన్నాయి.
 2 యొక్క పౌనఃపున్యం కలిగి - మరియు నేను ఉండటం వాటిని అన్ని కలిగి.
 తరువాత ఒక అత్యల్ప ASCII విలువ కలవి ఇవి?
 'A' మరియు 'L'. నేను కొత్త నోడ్ సృష్టించడానికి,
 మరియు చివరికి, అది 4 మరియు 2, కనుక 2 ఎడమ అన్నారు.
 మరియు మొదటి ఒకటి. నేను కొన్ని టెక్స్ట్ రాయాలనుకుంటున్నాను అప్పుడు ఉంటే,
 వంటి హఫ్ఫ్మన్ చెట్టు ఉపయోగించి, టెక్స్ట్ మార్చుకునేందుకు బైనరీ లో చాలా సులభం.
 నేను ఎడమ వెళ్లడం ఒక 0 మరియు కుడి కదిలే అని చెప్పుకోవాలంటే ఉదాహరణకు,, ఒక 1 ఉంది
 ఏ ప్రాతినిధ్యం అన్నారు అని?
 కాబట్టి వంటి 1, 1, కుడి, కాబట్టి కుడి,
 ఆపై కాబట్టి వదిలి 0, L ఉంటుంది, ఆపై 1, 0, 0.
 కాబట్టి 1, 0, కాబట్టి కేవలం 1, 0, 'ఒక'.
 ఆపై 0, 1, 'మేము.
 ఆపై 1, 0, 0 - ఏ.
 0, 0 'Y' అని, కాబట్టి లేజీ ఉంటుంది.
 కాబట్టి నాకు అంతే రాబ్ యొక్క స్వాధీనం అన్నారు.
 

[రాబ్ బౌడెన్], వారం 7 stuff.
 మేము నిజంగా ఫాస్ట్ వెళ్ళి చాలా పొందారు.
 Bitwise ఆపరేటర్లు, బఫర్ ఓవర్ఫ్లో,
 CS50 లైబ్రరీ, అప్పుడు HTML, HTTP, CSS.
 15 నుండి 20 నిమిషాలు వంటి అన్ని లో.
 Bitwise ఆపరేటర్లు. మీరు తెలుసుకోవాలి వాటిలో 6 ఉన్నాయి.
 Bitwise మరియు, bitwise లేదా, చెయ్యబడిన XOR, ఎడమ షిఫ్ట్, కుడి షిఫ్ట్, మరియు.
 కుడి Shift మరియు మీరు కేవలం అసలు ఉపన్యాసంలో పాటిస్తాయి.
 మేము త్వరగా ఇక్కడ పైగా వెళ్తారో కానీ ఈ ఉనికిలో 6 అని తెలుసుకోవడం మంచిది.
 Bitwise ఆపరేటర్లు మీరు + 4 3 చేసినప్పుడు వంటి అని గుర్తుంచుకోండి.
 మీరు 3 మరియు 4 యొక్క బైనరీ వ్యవహరించే లేదు.
 Bitwise ఆపరేటర్లు తో మీరు నిజంగానే 3 మరియు 4 యొక్క వ్యక్తిగత బిట్స్ వ్యవహరించే ఉంటాయి.
 

కాబట్టి మేము చెప్పడానికి మేము మొదటి ఒక bitwise, కాదు
 మరియు అది చిన్నబడి ఉంది.
 మీరు C లో వ్రాస్తున్నట్లయితే ఇక్కడ, మీరు రాయలేదు
 ~ 11011 లేదా ఎలాగైనా వంటి, మీరు, ఇది ~ 4 ఇష్టం రాస్తుంది
 ఆపై ఇది 4 యొక్క బైనరీ ప్రాతినిధ్యం కుదుపు చేస్తుంది.
 ఇక్కడ, 1 యొక్క ~ కొన్ని ద్వియాంశ సంఖ్య 1101101 ఖచ్చితంగా 0 యొక్క అన్ని 1 యొక్క ఫ్లిప్ అన్నారు మరియు అన్ని 0 యొక్క.
 ఓహ్, ఈ తరచుగా ఉపయోగిస్తారు,
 మేము కొన్ని సంఖ్య ఆలోచన కావలసిన వంటి మరియు మేము ఒక బిట్ లో చూస్తారు, ఉంది
 బిట్స్ అన్ని వాటిలో తప్ప, 1 ఎక్కడ.
 కనుక ఇది సంఖ్య వ్యక్తం సాధారణంగా సులభం
 కేవలం ఒక్క బిట్ సెట్ కౌంటీ,
 మరియు అది ~, కాబట్టి ప్రతి ఇతర బిట్ ఒక తప్ప సెట్ పడుతుంది.
 కాబట్టి మేము ఒక బిట్ మరింత ఉపయోగించడానికి వెళుతున్న ఏమిటి.
 

Bitwise లేదా. ఇక్కడ 2 బైనరీ సంఖ్యలు, మరియు ఈ 2 సంఖ్యలు
 వారు ప్రతి సాధ్యం ప్రాతినిధ్యం నుండి, అందంగా ప్రతినిధి
 బిట్స్ కలయిక మీరు అమలు చేయాలి కాలేదు.
 నేను ప్రతి బిట్ or'd ఉన్నప్పుడు ఇక్కడ, మేము నేరుగా డౌన్ పోల్చి చూడాలని.
 కాబట్టి ఎడమ వైపు మేము ఒక 1 మరియు ఒక 1.
 నేను bitwise చేసినప్పుడు | ఆ, నేను పొందడానికి వెళ్తున్నాను? ఒక.
 0 మరియు 1 నా ఇవ్వాలని అన్నారు | అప్పుడు bitwise? ఒక.
 Bitwise 1 మరియు 0 ఇదే, ఒకటిగా అన్నారు.
 Bitwise 0 | 0 నాకు 0 ఇవ్వాలని అన్నారు.
 0 సందర్భంలో | నేను, 0 చోటే మాత్రమే కేసు 0 లో ఉంది.
 మరియు మీరు కేవలం మీ తార్కిక ఇతరులు వంటి ఆలోచించవచ్చు.
 మీరు నిజమైన 1 మరియు తప్పుడు 0 అనుకుంటే కాబట్టి, ఇదే ఇక్కడ వర్తిస్తుంది.
 కాబట్టి నిజమైన లేదా నిజమైన పిలిచినది నిజమైన లేదా తప్పుడు నిజం.
 తప్పుడు లేదా నిజమైన పిలిచినది తప్పుడు లేదా తప్పుడు నిజానికి తప్పుడు అని మాత్రమే విషయం.
 ఇక్కడ మీరు తెలుసు ఉండాలని ఉదాహరణకు
 bitwise ఆపరేటర్లు ఉపయోగించినప్పుడు ఒక అందమైన మంచి ఉదాహరణగా.
 ఇక్కడ మేము లేదా Ox20 రాజధాని 'A',
 మరియు మేము ఏదో, రెండవ ఈ చూడండి.
 మరియు మేము లేదా చిన్న 'ఒక' Ox20 తో, మేము ఏదో పొందుటకు.
 కాబట్టి యొక్క ASCII పట్టిక పుల్ అప్ తెలియజేయండి.
 సరే. ఇక్కడ మేము 'ఒక' ఉందని -
 ఇక్కడ మేము 'ఒక' 65 దశాంశ కలిగి.
 కానీ నేను Ox41 ఇది హెక్సాడెసిమల్, తో వెళ్తారో.
 ప్రెట్టీ ఖచ్చితంగా మేము తరగతి లో చూశాడు. మనం తరగతి చూశాడు అనుకుంటున్నాను
 ఇది హెక్సాడెసిమల్ నుండి బైనరీ మార్చేందుకు అందంగా సులభం.
 ఇక్కడ, నేను బైనరీ లోకి 4 చాలు అనుకుంటే,
 కేవలం 0100 చేస్తాడు.
 ఈ 1 స్థానాన్ని, 2 యొక్క స్థానంలో, 4 యొక్క ప్రదేశం, ఈ 4 ఉంటుంది.
 అప్పుడు నేను 0001 మాత్రం ఇది బైనరీ, లోకి 1 విభజించబడింది.
 కాబట్టి ఈ బైనరీ లో 'ఒక' యొక్క ప్రాతినిధ్యం అన్నారు.
 చిన్న 'ఒక', అది ఇప్పుడు Ox61 చేస్తాడు తీసుకొని,
 దాని బైనరీ ఈ విభజన పేరు,, ఒక 6 -
 యొక్క దీన్ని లెట్ - ఏ eraser ఉంది? Eraser.
 Ox61. కాబట్టి బైనరీ లోకి 6 విభజన + 4 + 2 + 0 0 అన్నారు.
 మరియు విభజన 1 0001 అన్నారు.
 , ఈ 2 మధ్య వ్యత్యాసం చూడటం
 మేము ఒక చిన్న మరియు పెద్ద అక్షరం 'A' మధ్య తేడా ఈ బిట్ ఉందని.
 సరే - కాబట్టి తిరిగి ఇక్కడ వస్తున్న.
 మేము బిట్ Ox20 ఉంది ఏమి చూడండి అయితే,, ఇక్కడ తిరిగి వచ్చే
 దాని బైనరీ లోకి కాబట్టి విభజన Ox20,
 0010, 0000 ఉంది.
 Ox20, సెట్ మాత్రమే బిట్, మేము సంబంధించిన ఆ ఈ బిట్ ఉంది
 అక్షరాలు మరియు చిన్న 'ఒక' మధ్య మార్పిడి తో.
 ఈ ఒక, 'ఒక' ఇది నేను లేదా 'ఒక',,
 నేను లేదా Ox20 తో 'ఒక',
 నేను పొందడానికి వెళ్తున్నాను?
 [స్టూడెంట్, వినబడని] 

చిన్న 'ఒక', ఇది ఒక 1 ఈ బిట్ కుదుపు వెళుతున్న ఎందుకంటే.
 మరియు నేను లేదా 'ఒక' Ox20 తో, నేను పొందడానికి వెళ్తున్నాను?
 ఒక చిన్న, ఎందుకంటే కేవలం oring 'ఒక' Ox20 తో,
 నేను ఒక 1 ఈ బిట్ oring వెళుతున్న ఇది పట్టింపు లేదు కాబట్టి, ఇప్పటికే ఒక 1 ఉంది.
 మేము 'ఒక' మరియు 'ఒక' పొందండి.
 

Bitwise మరియు. మళ్లీ, మేము మా తార్కిక మరియు ప్రతిరూపమని ఈ యొక్క ఆలోచించవచ్చు.
 ఎడమవైపు మేము నిజమైన & నిజమైన కలిగి.
 ఇది, నిజమైన చేస్తాడు, మరియు కేసులు అన్ని కోసం ఉంది
 , తప్పుడు & నిజమైన లేదా నిజమైన & తప్పుడు, లేదా తప్పుడు & తప్పుడు
 ఆ ఊహలు నిజమైన.
 కాబట్టి మనం పొందడానికి ముగుస్తుంది 1000 ఉంది.
 కాబట్టి ఇప్పుడు, ఇక్కడ, ఇక్కడ నేను నమ్మదగిన bitwise కాదు ఉపయోగించిన పేరు ఉంది,
 మేము Ox20 కలిగి ఉన్న. కాబట్టి ఈ Ox20 ఉంది.
 ఇప్పుడు నేను మీరు ఏమి, bitwise Ox20 యొక్క ~.
 ఆ చిన్నబడి అన్నారు.
 నేను 1101, 1111 కలిగి.
 కాబట్టి 'ఒక' ~ Ox20 నాకు ఏమి ఇవ్వాలని అన్నారు తో anded?
 మేము నిజంగా గురించి ఆలోచించడానికి మాత్రమే బిట్, ఈ ఒకటి
 నుండి, ఈ బిట్స్ అన్ని 1 కు సెట్ ఉంటే,
 అప్పుడు మేము ఖచ్చితంగా 'ఒక' ఉంది పొందడానికి వెళుతున్న,
 తప్ప, బహుశా, ఈ బిట్ ఉంది.
 ఇది ఒక 1 ఉంది, ఇప్పుడు అది, ఒక 0 సెట్ చేస్తాడు ఎందుకంటే
 ఈ ఏమైనా ఈ 0 అన్నారు తో anded ఎందుకంటే.
 కాబట్టి 'ఒక' ~ Ox20 నాకు ఇవ్వాలని అన్నారు & ఏమిటి?
 [స్టూడెంట్స్ సమాధానం, వినబడని] 

మరియు 'ఒక' మరియు ఏ - ఇది 'A' ఉంది.
 మరియు 'ఒక' & ~ Ox20 నాకు ఇవ్వాలని అన్నారు ఏమిటి?
 'ఎ' ఈ ప్రస్తుతం ఒక 1 ఎందుకంటే.
 ఈ 0 తో Anding, ఇది ఒక 0 సిధ్ధంగా ఉంటుంది
 మరియు ఇప్పుడు మేము ఒక 'ఒక' ను చూడాలని.
 

రెండు ', ఒక' మరియు ఈ రకమైన గత కానీ కనీసం,
 మేము చెయ్యబడిన XOR కలిగి. ఇది చాలా వంటిది లేదా,
 ఇది ప్రత్యేకంగా అర్థం లేదా మినహా.
 ఈ మీరు సాధారణంగా లేదా వాస్తవ ప్రపంచంలో యొక్క ఏమనుకుంటున్నారో వంటిది.
 కాబట్టి మీరు 'x' లేదా 'Y', కానీ రొండు.
 ఇక్కడ ^ 1 1 0 అన్నారు.
 నిజమైన, ఈ - ఇది తార్కిక నిజమైన మరియు తప్పుడు తో అదే పని లేదు
 , bitwise & మరియు లేదా వంటి
 కానీ నిజమైన ^ నిజమైన FALSE.
 వాటిని మాత్రమే ఒక నిజమైన ఉంటే మేము మాత్రమే నిజమైన తిరిగి తెచ్చుకున్నాయి.
 కాబట్టి ^ 1 1 0. ఏ ^ 1 0 గురించి?
 1 ఉంది. ^ 0 1 ^ 0 0 0, 1 ఉంది.
 కాబట్టి అన్ని పరిస్థితులలో, 0 bitwise ఏదో 0 0 అన్నారు.
 1 bitwise ఏదో 0 లేదా 0 bitwise 1,
 అది ఉంటే | లేదా ^, ఇది ఒక 1 ఉంటాం, మరియు అది, అయితే అది 0 ఉంటాం.
 మరియు 1 bitwise 1 1 లేనిచోట మాత్రమే కేసు ప్రత్యేక లేదా తో ఉంది.
 ఆ 0110 ఉంది.
 ఇక్కడ ఇప్పుడు, చెయ్యబడిన XOR ఉపయోగించి - కాబట్టి మేము తిరిగి 20 వద్ద ఉన్నారు.
 'ఒక' ^ Ox20 మేము పోలుస్తున్నారు ఈ 2 బిట్స్ ఉంది.
 కాబట్టి ఒక 1 ^ 0 నాకు ఒక ఏమి ఇవ్వాలని అన్నారు? ఒక ఒక.
 'ఒక' ^ Ox20 నాకు ఇవ్వాలని అన్నారు? ఒక చిన్న.
 'ఒక' ^ Ox20 నాకు ఇవ్వాలని అన్నారు? రాజధాని A.
 ఈ చేయడం ఏమైనా, Ox20 ఈ XORing
 గంగారావు బిట్ సంసార వేగంగా కదలటం ఉంది.
 ఈ ఒక 0 అయితే, అది ఇప్పుడు ఒక 1 మారింది వెళుతున్న.
 ఈ ఒక 1 నుండి, ^ 1 1 0.
 మా 'ఒక' 'ఒక' మారింది, మరియు మా 'ఒక' 'ఒక' మారింది.
 కాబట్టి చెయ్యబడిన XOR ఒకవేళ వేగంగా కదలటం ఒక నిజంగా మార్గమే.
 మీరు అక్షరాలు ఒక స్ట్రింగ్ పైగా iterate మీరు
 మరియు ప్రతి పాత్ర విషయంలో ప్రత్యామ్నాయ,
 Ox20 మీకు చెయ్యబడిన XOR ప్రతిదీ.
 

ఇప్పుడు మేము తెలీదు. ఎడమ షిఫ్ట్ కేవలం, ప్రాథమికంగా, అన్నారు
 లోకి, లేదా ఎడమ సంఖ్యల అన్ని పుష్, మరియు వాటిని వెనుక 0 యొక్క ఇన్సర్ట్.
 కాబట్టి ఇక్కడ 00001101 కలిగి.
 మేము, కుడి నుండి 3 0 యొక్క లో పుష్ చూడాలని
 మరియు మేము 01101000 పొందండి.
 Nonbinary పరంగా,
 మేము నిజంగా 13 ఎడమ మార్చారు 3 తో, మాకు 104 ఇస్తుంది వ్యవహరించే చేసే చూడండి.
 కాబట్టి ఎడమ బదిలీ, మేము ఇక్కడ చూడండి, x << y ప్రాథమికంగా x * 2 ^ y ఉంది.
 ^ 3 13 * 2, ^ 3 2 కాబట్టి * 8 13 104 ఉంది, 8.
 మీరు సాధారణంగా బైనరీ, ఎలా ప్రతి అంకెల, గురించి అనుకుంటే
 మేము కుడి నుండి ప్రారంభం, అప్పుడు అది 1 యొక్క ప్రదేశం, అప్పుడు 2 యొక్క స్థానంలో, 4 యొక్క స్థానం.
 కాబట్టి కుడి నుండి 0 యొక్క మోపడం ద్వారా,
 మేము, 8 యొక్క స్థానానికి 4 యొక్క సమకూరాయి ఆ విషయాలు నెట్టడం
 మరియు 16 యొక్క స్థానానికి 8 యొక్క సమకూరాయి ఆ విషయాలు.
 ప్రతి మార్పు కేవలం 2 ద్వారా గుణిస్తారు. అవును?
 మీరు 5 ద్వారా మార్చబడుతుంది ఉంటే [స్టూడెంట్] ఏం జరుగుతుందో?
 [బౌడెన్] మీరు 5 ద్వారా మార్చబడుతుంది ఉంటే మీరు అంకెలు కోల్పోతుంది.
 అనివార్యంగా, అదే విషయం. వంటి, పూర్ణ మాత్రమే 32 బిట్స్ ఉంటాయి,
 మీరు 2 నిజంగా పెద్ద పూర్ణాంకాల జోడిస్తే అంతేకాదు, ఇది ఒక పూర్ణ అధిగమించడంలో లేదు.
 కనుక ఇది ఇక్కడ అదే విషయం. మీరు 5 ద్వారా మార్చబడుతుంది ఉంటే,
 మేము ఒక కోల్పోతుంది.
 మరియు ఆ ", సుమారు" నేను కుట్టినది రకంగా
 మీరు చాలా దూరం మార్చేందుకు, మీరు బిట్స్ కోల్పోతారు పేరు.
 

కుడి షిఫ్ట్ సరసన అన్నారు,
 మేము, ముగింపు ఆఫ్ 0 యొక్క బలంగా త్రోయు వెళుతున్న
 మరియు ఏవండీ, ఎడమ నుండి 0 యొక్క పూరించండి.
 కాబట్టి ఈ చేయడం, ప్రధానంగా మేము ఇప్పటికే చేసిన విపర్యయ చేస్తున్నారు.
 మరియు మేము, కుడి మూడు 0 యొక్క కేవలం ఆఫ్ పడిపోయిన ఆ చూడండి
 మరియు మేము కుడి 1101 అన్ని మార్గం పిలుపునిస్తున్నారు.
 ఈ సమర్థవంతంగా, x / 2 ^ y, ఇది, 104 

3 చేస్తోంది.
 కాబట్టి ఇప్పుడు, ఇక్కడ, అది ఇదే ఆలోచన.
 ఎందుకు అది సుమారు x / 2 ^ y, మరియు నిజానికి x / 2 ^ y?
 నేను 4 ద్వారా మార్చబడుతుంది ఉంటే, నేను ఒక 1 కోల్పోయారు ఉండేది ఎందుకంటే.
 సాధారణంగా, కేవలం సాధారణంగా పూర్ణాంక విభాగంలో ఏ మీరు అనుకుంటున్నారో, అనుకుంటున్నాను.
 కాబట్టి, 5/2 వంటి 2. ఇది 2.5 కాదు.
 ఇది ఇక్కడ అదే ఆలోచన. మేము 2 విభజించడానికి, చేసినప్పుడు
 మేము మార్గం వెంట బేసి బిట్స్ కోల్పోతారు.
 కాబట్టి ఇప్పుడు - ఆ bitwise కోసం ఇది. మీరు తెలుసుకోవాలి అన్ని ఉంది.
 మేము తరగతి లో చూసిన ఈ నుంచి,
 వంటి బిట్ ముసుగు, bitwise ఆపరేటర్లు పనికొచ్చే
 లేదా మీరు బిట్ ముసుగులు కోసం వాటిని ఉపయోగించే.
 పెద్ద అక్షరాలు మరియు చిన్న అక్షరాలు, మార్పిడులు ఒక అందమైన ప్రాధమిక ఉదాహరణ.
 

సరే, ఓవర్ఫ్లో దాడులు స్వీకరించేందుకు.
 ఎవరైనా ఈ ఫంక్షన్ తో తప్పు ఏమి గుర్తు?
 మేము 12 బైట్లు యొక్క వ్యూహం, 12 అక్షరాలు, డిక్లేర్డ్ గమనించండి
 మరియు తర్వాత మేము 12 అక్షరాలు మొత్తం స్ట్రింగ్ బార్ మా బఫర్ లోకి కాపీ. కాబట్టి సమస్య ఇక్కడ ఏముంది?
 ఎందుకు 12 - మేజిక్ సంఖ్య 12 వెంటనే అందంగా చాలా వంటి పాప్ ఉండాలి?
 బార్ కంటే ఎక్కువ 12 అక్షరాలు ఉండాలి ఏమి ఉంటే?
 ఏ బార్ అక్షరాలను మిలియన్ల ఉంటే?
 ఇక్కడ సమస్య memcpy ఉంది. బార్ దీర్ఘకాలం, ఉంటే
 ఇది పూర్తిగా ఉంటుంది - 'సి', 'సి' ఇది కేవలం 12 అక్షరాలు అని పట్టించుకోరు;
 'సి' ఇది అనేక బైట్లు సరిపోవు పట్టించుకోరు.
 ఇది కేవలం పూర్తిగా చార్ తిరిగి రాస్తుంది, మేము అది కోసం కేటాయించింది చేసిన 12 బైట్లు,
 మరియు మెమరీ లో గత అంశం నిజానికి ఆ బఫర్ చెందిన లేదు
 సంసార స్ట్రింగ్ బార్ తో.
 ఈ మేము తరగతి లో చూసింది చిత్రం ఉంది
 మేము మా స్టాక్ పెరుగుతూ ఉంటుంది.
 మీరు ఈ చిత్రాలు ఉపయోగిస్తారు లేదా మళ్ళీ వాటిని జలవివాదం చేయాలి.
 మేము మా స్టాక్ పెరుగుతూ కలిగి, మెమరీ చిరునామాలను ఎగువన 0 వద్ద మొదలు
 మరియు దిగువన 4 బిలియన్ ఇష్టం డౌన్ పెరుగుతాయి.
 మేము, ఎక్కడో మెమరీలో మా శ్రేణి 'సి' కలిగి
 అప్పుడు మేము అది కింద బార్ మా పాయింటర్ కలిగి,
 మరియు తర్వాత మేము ఈ సేవ్ ఫ్రేమ్ మా తిరిగి చిరునామా లో పాయింటర్ మరియు మా మాతృ రొటీన్ యొక్క స్టాక్.
 తిరిగి చిరునామా ఏమిటి మర్చిపోయారా?
 ప్రధాన ఒక ఫంక్షన్ కాల్స్ బార్, ఒక ఫంక్షన్ foo కాల్స్ అది, ఉంది
 అనివార్యంగా, తిరిగి బార్.
 కాబట్టి బార్ తిరిగి, వారు అది అని foo తిరిగి వెళుతున్న తెలుసు అవసరం.
 కాబట్టి తిరిగి చిరునామా ఉన్నప్పుడు తిరిగి తిరిగి అది ఉంది ఫంక్షన్ యొక్క చిరునామా.
 , సౌకర్యవంతంగా, ఎందుకంటే బఫర్ ఓవర్ఫ్లో దాడులు కోసం ముఖ్యమైన కారణం
 హ్యాకర్లు ఆ తిరిగి చిరునామా మార్చాలనుకుంటున్న.
 బదులుగా తిరిగి foo వెళ్లి, నేను తిరిగి హ్యాకర్ నాకు తిరిగి వెళ్ళడానికి తనకు ఎక్కడ వెళ్ళండి వెళుతున్న.
 మరియు, సౌకర్యవంతంగా, హ్యాకర్ తరచుగా తిరిగి వెళ్ళడానికి అనుకుంటుంది
 మేము అసలు ఉందని బఫర్ ప్రారంభంలో ఉంది.
 కాబట్టి, మళ్ళీ, లిటిల్ భారత గమనించవచ్చు.
 ఉపకరణం ఒక లిటిల్ భారత వ్యవస్థ యొక్క ఒక ఉదాహరణ,
 కాబట్టి పూర్ణాంకం లేదా ఒక పాయింటర్ తిరిగి బైట్లు తో నిల్వ.
 కాబట్టి ఇక్కడ చూడండి - ఈ ఉంది? అవును.
 మేము Ox80, OxC0, Ox35, OxO8 చూడండి.
 హెక్సాడెసిమల్ మర్చిపోయారా?
 మేము, లిటిల్ భారత లో హెక్సాడెసిమల్ రివర్స్ లేదు
 2 హెక్సాడెసిమల్ ఒక బైట్ తయారు, మరియు మేము బైట్లు రివర్స్ ఎందుకంటే.
 ఎందుకు మేము, వంటి, 80530CO8 నిల్వ లేదు పేర్కొంది.
 మేము కుడి నుండి ప్రారంభించబడుతుంది,, బదులుగా, 2 అంకెలు ప్రతి జంట నిల్వ.
 ఆ చిరునామా ప్రారంభానికి చిరునామా సూచిస్తుంది
 మేము నిజంగా మొదటి స్థానంలో లోకి కాపీ కోరుకున్నాడు మా బఫర్ యొక్క.
 ఉపయోగం గల కారణం ఏమి ఎందుకంటే, దాడి
 బదులుగా కేవలం స్ట్రింగ్ కలిగి, జరిగిన
 వంటి ఒక ప్రమాదకరం స్ట్రింగ్, వారి పేరు లేదా ఏదో,
 ఏం, బదులుగా, ఆ స్ట్రింగ్ కొన్ని ఏకపక్ష కోడ్ ఉన్నారు
 వారు అది ఏది కోరుకుంటే చేశాడు?
 కాబట్టి వారు కాలేదు - నేను ఏదైనా చల్లని కోడ్ భావిస్తారు కాదు.
 ఇది అయితే, ఏదైనా కావచ్చు. ఏ ఘోరమైన కోడ్.
 వారు అనుకుంటే, వారు కేవలం seg లోపాలు వద్ద ఏదో, అయితే ఆ అర్ధం ఉంటుంది.
 వారు సాధారణంగా మీ సిస్టమ్ హాక్ చేస్తున్నాయి.
 సరే >>. CS50 లైబ్రరీ.
 ఈ, ప్రధానంగా, GetInt, GetString, అన్ని విధులు మేము మీరు కోసం అందించబడింది.
 కాబట్టి మేము చార్ * స్ట్రింగ్ కలిగి, మరియు మేము దూరంగా పేల్చి సంగ్రహణం ఉంది
 సెమిస్టర్ సమయంలో ఏదో ఒక సమయంలో.
 ఒక స్ట్రింగ్ కేవలం అక్షరాల యొక్క శ్రేణి అని గుర్తుంచుకోండి.
 కాబట్టి ఇక్కడ getString ఒక కుదించబడిన చూడండి.
 మీరు నిజానికి అమలు ఎలా గుర్తు, తిరిగి చూడాలని.
 కీ వివరాలు ఉంటాయి, మేము ఒక సమయంలో ఒక పాత్ర లో పొందండి గమనించవచ్చు
 కేవలం మాకు కీబోర్డ్ వద్ద టైప్ పోలియున్నది లో నుంచి.
 కాబట్టి ఒక సమయంలో ఒకే పాత్ర, మరియు మేము చాలా అక్షరాలు వస్తే,
 కాబట్టి n + 1 సామర్థ్యం కంటే ఎక్కువ ఉంటే,
 అప్పుడు మేము మా బఫర్ యొక్క సామర్థ్యాన్ని అవసరం.
 కాబట్టి మేము ఎలా స్ట్రింగ్ యొక్క పరిమాణం రెట్టింపు చేస్తున్నారు.
 మరియు ఆ వెళ్ళి ఉంచుతుంది; మేము మా బఫర్ లోకి పాత్ర ఇన్సర్ట్
 మేము ఒక కొత్త లైన్ లేదా ఫైలు లేదా వస్తువు యొక్క ముగింపు అందుకుంటారు వరకు,
 ఈ సందర్భంలో, మేము స్ట్రింగ్ మరియు నిజ getString పూర్తి చేసిన
 మేము చాలా మెమరీ కేటాయించింది ఉంటే అది తిరిగి వెళ్లి ఒక బిట్ ముడుచుకునే చేస్తాము వంటి, మెమరీ తగ్గిస్తుంది.
 కాబట్టి మేము ఆ చూపవద్దు, కానీ ప్రధాన ఆలోచన
 ఇది ఒక సమయంలో ఒకే పాత్ర చదవడానికి కలిగి.
 ఇది కేవలం ఒకేసారి ఒక మొత్తం విషయం లో చదువలేదు
 వారి బఫర్ ఒక నిర్దిష్ట పరిమాణం యొక్క ఎందుకంటే.
 ఇది బఫర్ లోకి ఇన్సర్ట్ ప్రయత్నిస్తుంది స్ట్రింగ్ చాలా పెద్దది చేస్తే, అది ఓవర్ఫ్లో అని.
 కాబట్టి ఇక్కడ నిరోధించే ఒకే పాత్ర లో చదవడం ద్వారా
 ఒక సమయంలో మరియు మేము అవసరం చేసినప్పుడు పెరుగుతున్న.
 కాబట్టి GetInt మరియు ఇతర CS50 లైబ్రరీ విధులు getString ఉపయోగించడానికి ఉంటాయి
 వారి అమలు లో.
 నేను ఇక్కడ ముఖ్యమైన విషయాలు హైలైట్.
 ఇది ఒక స్ట్రింగ్ పొందడానికి తెలుసా.
 GetString మెమరీ తిరిగి విఫలమైంది,
 getString ఏదో mallocs గుర్తుంచుకోవాలి, కాబట్టి మీరు getString కాల్ చేసినప్పుడు
 మీరు (అపారదర్శక) మీరు వచ్చింది అని స్ట్రింగ్ విడిపించేందుకు లేదు.
 ఇది ఏదో malloc విఫలమైంది ఉంటే ఇక్కడ, మేము ఒక జెండాగా INT_MAX తిరిగి,
 హే, మేము నిజంగా ఒక పూర్ణ సంఖ్య చెయ్యలేకపోయాము.
 మీరు నేను మీరు తిరిగి సంసార విస్మరించు లేదా ఉండాలి
 మీరు చెల్లుబాటు అయ్యే ఇన్పుట్ ఈ చికిత్స. చివరిగా, విజయం సాధించాడు ఊహిస్తూ, మేము, ప్రత్యేక జెండా sscanf ఉపయోగించడానికి
 అంటే, మొదటి పూర్ణాంకం మ్యాచ్,
 ఆ పూర్ణాంక తర్వాత ఏ అక్షరాలు మ్యాచ్.
 కాబట్టి మేము అది 1 సమానంగా కావలసిన గమనించవచ్చు.
 కాబట్టి sscanf తిరిగి విజయవంతంగా ఎన్ని మ్యాచ్ల చేసిన ఉంటే?
 ఇది విజయవంతంగా పూర్ణాంకం సరిపోలే ఉంటే 1 చూపిస్తుంది,
 పూర్ణాంకం సరిపోలడం లేదు ఉంటే ఇది 0 తిరిగి, మరియు అది 2 తిరిగి
 సరిపోలలేదు ఉంటే పూర్ణాంకం కొన్ని పాత్ర తరువాత.
 కాబట్టి మేము 1 ఏదైనా కానీ మ్యాచ్ ఉంటే మేము మళ్ళీ గమనించవచ్చు.
 కాబట్టి మేము ఎంటర్ చేస్తే 1, 2, 3, సి, లేదా 1, 2, 3, X,
 అప్పుడు 1, 2, 3 పూర్ణాంక నిల్వ ఉంటుంది,
 X, పాత్ర వద్ద నిల్వ చేయబడుతుంది
 మేము మాత్రమే పూర్ణాంకం కావలసిన ఎందుకంటే, sscanf 2 తిరిగి, మరియు మేము మళ్ళీ చేస్తుంది.
 

త్వరగా HTML, HTTP, CSS యొక్క వీచే.
 హైపర్టెక్స్ట్ మార్కప్ లాంగ్వేజ్ వెబ్ యొక్క నిర్మాణం మరియు అర్థాలను ఉంది.
 ఇక్కడ మేము HTML టాగ్లు పేరు ఉపన్యాసం నుండి ఉదాహరణ.
 మేము తల టాగ్లు, శరీరం టాగ్లు, కలిగి
 మేము, మేము నిజంగా ఒక ప్రారంభ మరియు దగ్గరగా ట్యాగ్ లేదు పేరు ఖాళీ టాగ్ ఉదాహరణలు ఉన్నాయి
 మేము లింక్ మరియు చిత్రం కలిగి.
 ఏ ముగింపు చిత్రం ట్యాగ్ ఉంది; ట్యాగ్ చేయవలసిన ప్రతిదీ సాధించింది కేవలం ఒకే ట్యాగ్ ఉంది.
 లింక్ ఒక ఉదాహరణ; మీరు CSS లింక్ ఎలా చూస్తారు,
 స్క్రిప్ట్ మీరు ఒక బాహ్య జావాస్క్రిప్ట్ ఎలా లింక్ యొక్క ఒక ఉదాహరణ.
 ఇది HTML ఒక ప్రోగ్రామింగ్ భాష కాదు, సూటిగా ఉంది, మరియు గుర్తుంచుకోండి.
 ఇక్కడ, మీరు ఈ ఏమి చేస్తుంది ఒక రూపంలో నిర్వచించే లేదా కనీసం ఎలా గుర్తు?
 ఒక రూపం ఒక చర్య మరియు ఒక పద్ధతి ఉంది.
 మీరు మాత్రమే ఎప్పుడూ చూస్తారు పద్ధతులు GET మరియు POST ఉంటాయి.
 కాబట్టి GET విషయం URL లో ఉంచే పేరు వెర్షన్.
 ఇది URL లో పెట్టలేదు రాష్ట్రం టపా.
 బదులుగా, రూపం నుండి ఏ డేటా HTTP అభ్యర్థన లో రహస్య చేర్చబడుతుంది.
 HTTP అభ్యర్థన వెళ్ళే ఇక్కడ, చర్య నిర్వచిస్తుంది.
 ఏమైందా ఎక్కడ google.com / శోధన.
 విధానం. GET మరియు POST మధ్య తేడాలు గుర్తుంచుకోండి,
 మీరు బుక్మార్క్ ఏదో అనుకుంటే, కేవలం, ఒక ఉదాహరణగా చెప్పడానికి.
 మీరు ఒక POST URL బుక్మార్క్ చేయగలరు ఎప్పటికీ
 డేటా URL చేర్చబడలేదు ఎందుకంటే.
 

HTTP, ఇప్పుడు, హైపర్టెక్స్ట్ ట్రాన్స్ఫర్ ప్రోటోకాల్ ఉంది.
 హైపర్టెక్స్ట్ ట్రాన్స్ఫర్ ప్రోటోకాల్, మీరు బదిలీ ఆలోచించే
 హైపర్టెక్స్ట్ మార్కప్ లాంగ్వేజ్, మరియు అది.
 కానీ అది మీరు వెబ్ లో ఏ చిత్రాలు బదిలీ,
 మీ సంప్రదింపులన్నిటిలోనూ డౌన్ ఒక HTTP అభ్యర్థన గా మొదలు.
 కాబట్టి HTTP కేవలం వరల్డ్ వైడ్ వెబ్ యొక్క భాష.
 మరియు ఇక్కడ మీరు ఒక HTTP అభ్యర్థన ఈ రకమైన గుర్తించడానికి అవసరం.
 వైపు ఇక్కడ HTTP/1.1 ఆ సంస్కరణ చెప్పారు
 ప్రోటోకాల్ యొక్క నేను ఉపయోగించి వెబ్.
 మీరు చూస్తారు ఇది ఎల్లప్పుడూ, HTTP/1.1 చేస్తాడు.
 అప్పుడు మేము ఈ మీరు చూడండి అని, ప్రత్యామ్నాయ POST ఉండటం, GET సంపాదించెను.
 మరియు నేను సందర్శించిన ప్రయత్నిస్తోందని URL www.google.com/search?q = బ్లా, బ్లా, బ్లా ఉంది.
 కాబట్టి గుర్తు ఈ, ప్రశ్న గుర్తు q = బ్లా బ్లా బ్లా,
 ఒక రూపం సమర్పించిన అని stuff యొక్క విధమైన ఉంది.
 ఇది నాకు వెళ్ళి ఎప్పుడూ ఈ వంటి ఏదో చూస్తారు.
 మళ్ళీ, ఆ మాత్రం ప్రొటోకాల్, ప్రారంభించి,
 స్థితి కోడ్ ద్వారా. ఇక్కడ ఇది 200 సరే.
 చివరకు, నేను నిజానికి అడిగారు వెబ్ పేజీ తరువాత చేయబడుతుంది.
 సాధ్యం స్థితి కోడ్ మీరు చూడవచ్చు, మరియు మీరు వాటిని అనేక తెలుసుకోవాలి.
 200 OK మీరు బహుశా ముందు చూసిన.
 403 నిషిద్ధ, 404 దొరకలేదు, 500 అంతర్గత సర్వర్ లోపం
 మీరు ఒక వెబ్ సైట్ కు వెళ్ళి ఏదో విభజించబడింది లేదా వారి PHP కోడ్ క్రాష్ అయితే, సాధారణంగా ఉంది
 పరికరంలోని మేము అయితే పెద్ద నారింజ బాక్స్
 ఆ వస్తుంది మరియు వంటి, ఏదో తప్పు ఉంది, చెప్పారు, ఈ కోడ్ పని లేదు
 లేదా ఈ ఫంక్షన్ యొక్క చెడు.
 సాధారణంగా వెబ్సైట్లు, మీరు విధులు చెడు ఏమిటో తెలుసుకోవటం లేదు
 కాబట్టి బదులుగా వారు కేవలం మీరు 500 అంతర్గత సర్వర్ లోపాలు ఇస్తాము.
 

TCP / IP HTTP క్రింద 1 పొర.
 ఇంటర్నెట్ వరల్డ్ వైడ్ వెబ్ వెలుపల ఉంది గుర్తుంచుకోవాలి.
 ఇలా మీరు HTTP ద్వారా పోదు ఒక ఆన్లైన్ ఉంటే,
 అది వేరే ద్వారా జరగబోతోంది - ఇది ఇప్పటికీ ఇంటర్నెట్ ఉపయోగించి,
 కానీ HTTP ఉపయోగించదు.
 HTTP TCP / IP నిర్మించబడింది ప్రోటోకాల్ యొక్క కేవలం ఒక ఉదాహరణ.
 IP వాచ్యంగా ఇంటర్నెట్ ప్రోటోకాల్ అంటే.
 ప్రతి కంప్యూటర్కు IP చిరునామా కలిగి; ఆ 4 అంకెల విషయాలు
 192.168.2.1, లేదా సంసార వంటి కేటాయి ఒక స్థానిక ఒక ఉంటుంది.
 కానీ ఒక IP చిరునామా యొక్క నమూనా ఉంది.
 కాబట్టి DNS, డొమైన్ పేరు సర్వీస్,
 ఒక వాస్తవ IP చిరునామాకు google.com వంటి విషయాలు అనువాదం ఏమిటి.
 కాబట్టి మీరు ఒక URL ఆ IP చిరునామా టైప్ ఉంటే,
 మీరు Google కు మీరు తీసుకొచ్చే, కానీ మీరు ఆ విషయాలు గుర్తుంచుకోవడం ఇవ్వలేవు.
 బదులుగా మీరు google.com గుర్తుంచుకోండి ఉంటాయి.
 మేము గత విషయం ఈ IP యొక్క TCP భాగం పోర్ట్సు, ఉంది.
 TCP ఎక్కువ చేస్తుంది. మీరు మీ బ్రౌజర్ ను కలిగి, వంటి, గురించి ఆలోచించండి.
 బహుశా మీరు కొన్ని ఇమెయిల్ అప్లికేషన్ అమలు;
 బహుశా మీరు ఇంటర్నెట్ నడుస్తున్న ఉపయోగించే కొన్ని ఇతర ప్రోగ్రామ్ను.
 వారు అన్ని ఇంటర్నెట్ యాక్సెస్ అవసరం,
 కానీ మీ కంప్యూటర్ మాత్రమే 1 వైఫై కార్డ్ లేదా సంసార ఉంది.
 కాబట్టి పోర్ట్సు మేము విభజించగలదు అని మార్గం
 ఈ అనువర్తనాల్లో ఇంటర్నెట్ ఉపయోగించడానికి చేయగలరు ఎంత.
 ప్రతి అనువర్తనం, ఇది వింటుంది చేసే 1 ప్రత్యేక పోర్ట్ గెట్స్
 మరియు డిఫాల్ట్గా, HTTP పోర్ట్ 80 ఉపయోగిస్తుంది. కొన్ని ఇమెయిల్ సేవలు 25 ఉపయోగించడానికి.
 తక్కువ సంఖ్య వాటిని రిజర్వు ఉంటాయి.
 మీరు సాధారణంగా మీ కోసం అధిక సంఖ్యలో వాటిని పొందడానికి చేయగలరు.
 

CSS, క్యాస్కేడింగ్ స్టైల్ షీట్లు.
 CSS తో మేము శైలి వెబ్ పేజీలకు, కాదు HTML తో.
 మీరు మీ CSS ఉంచవచ్చు 3 స్థలాలు ఉన్నాయి.
 ఇది శైలి టాగ్లు మధ్య, లేదా ఒక ప్రత్యేక పూర్తిగా ఫైలులో ఆపై సైన్ లింక్, ఇన్లైన్ ఉంటుంది
 మరియు ఇక్కడ CSS కేవలం ఒక ఉదాహరణ.
 మీరు ఈ నమూనా గుర్తించాలి,
 మొదటి ఉదాహరణ మేము శరీరం ట్యాగ్ సరిపోలే, చేస్తున్నారు పేరు
 మరియు ఇక్కడ మేము శరీరం ట్యాగ్ కేంద్రీకృతం చేస్తున్నారు.
 రెండవది, మేము విషయం సరిపోలే ఉంటాయి
 ID ఫుటరు తో, మరియు మేము ఆ కొన్ని శైలులు దరఖాస్తు చేస్తున్నారు.
 ఎడమ ఆ ID ఫుటరు టెక్స్ట్ సర్దుబాటు గమనించండి,
 శరీరం టెక్స్ట్-సర్దుబాటు సెంటర్ అయితే.
 ఫుటరు శరీరంలోనే ఉంది.
 ఇది, బదులుగా, text-align శరీర text-align సెంటర్ చెప్పారు అయినప్పటికీ, వదిలి ఉంటుంది.
 ఇది మొత్తం కాస్కేడింగ్ భాగం.
 మీరు కలిగి - మీరు శరీరం కోసం శైలులు పేర్కొనవచ్చు,
 మరియు తర్వాత శరీరంలో విషయాలు మీరు మరింత ప్రత్యేక శైలులు పేర్కొనవచ్చు,
 మరియు విషయాలు మీరు ఆశించిన విధంగా పని.
 మరింత నిర్దిష్ట CSS specifiers ప్రాధాన్యత వహిస్తాయి.
 నేను బయటకు తియ్యి.
 

[ఆలీ Nahm] ఒక్కరూ ఎక్కువ. నేను మీ దృష్టిని ఆకర్షించింది అని.
 నేను ఆలీ నేను నిజంగా వేగంగా PHP మరియు SQL ద్వారా వెళ్ళడానికి వెళుతున్న.
 కాబట్టి మేము ప్రారంభించవచ్చు. PHP PHP సంక్షిప్తరూపం: హైపర్టెక్స్ట్ ప్రీప్రాసెసర్.
 మీకు తెలుసు ఉండాలి మరియు ఇది ఒక సర్వర్ వైపు స్క్రిప్టింగ్ భాష,
 మరియు మేము వెబ్సైట్లు వెనుక ముగింపు కోసం దీనిని ఉపయోగిస్తారు,
 మరియు గణనలు, తెర వెనుక భాగం చాలా చేస్తుంది ఎలా.
 సింటాక్స్. ఇది C, ఆశ్చర్యం, ఆశ్చర్యం ఇష్టం లేదు.
 నేను ముందుకు తరలించడానికి కాదు - ఇది ఎల్లప్పుడూ మీరు చూడగలరు ఉంటే,, ప్రారంభం ఉంది.
 మీరు జంట కలుపులు కొత్త రకాల అవసరం చూడగలరు మరియు మీరు కూడా? Php అవసరం.
 మీరు మీ PHP టెక్స్ట్, మీ PHP కోడ్ ఫ్రేమ్ కలిగి ఎప్పుడూ ఉంది.
 కాబట్టి ఇది మీరు రకమైన మొదటి దానిపై నెలకొల్పాడు సి, ఇలా ఉంటుంది.
 మీరు దాని చుట్టూ అవసరం.
 ఇప్పుడు, ప్రధాన వాక్యనిర్మాణం అన్ని వేరియబుల్స్ $ పాత్ర ప్రారంభం అవసరం ఉంది.
 మీరు వాటిని నిర్వచించు చేసినప్పుడు అది చేయాలి; మీరు దీన్ని అవసరం
 మీరు తర్వాత వారికి సూచిస్తూ చేసినప్పుడు.
 మీరు ఎప్పుడూ $ అవసరం. ఇది చాలా చక్కని, మీ కొత్త స్నేహితుడి ఉంది.
 మీరు లేదు - సి కాకుండా, మీరు వేరియబుల్ రకం ఏ విధమైన ఉంచాలి లేదు.
 మీరు $ అవసరం అందువలన, మీరు, వంటి, ఉంచాలి లేదు
 , Int x లేదా స్ట్రింగ్ y, మొదలగునవి, మొదలగునవి.
 కాబట్టి కొద్దిగా తేడా.
 ఈ ఫలితంగా, అది PHP ఒక బలహీనంగా రకం అని అర్థం.
 PHP ఒక బలహీనంగా రకం భాష, మరియు ఇది బలహీనంగా వేరియబుల్స్ టైప్ చేసారు.
 ఇతర మాటలలో, మీరు వేరియబుల్ రకాల వివిధ రకాల మధ్య మారవచ్చు అర్థం.
 మీరు ఒక Int వంటి మీ సంఖ్య 1 నిల్వ చేయవచ్చు,
 మీరు ఒక స్ట్రింగ్ వంటి నిల్వ చేయవచ్చు, మరియు మీరు ఒక ఫ్లోట్ గా నిల్వ చేయవచ్చు,
 మరియు ఆ సంఖ్య 1 ఉంటుంది.
 మీరు వివిధ రూపాల్లో నిల్వ ఉన్నప్పటికీ,
 ఇప్పటికీ - వేరియబుల్ రకాల ఇప్పటికీ చివరికి పట్టుకొని ఉంటాయి.
 కాబట్టి మీరు ఇక్కడ చూస్తే, మీరు pset 7 నుండి గుర్తుంచుకుంటే,
 మీరు అనేక బహుశా ఈ సమస్యలను కలిగి.
 రెండు సమాన సంకేతాలు, 3 సమాన సంకేతాలు, 4 సమాన సంకేతాలు.
 సరే, ఏ 4 సమాన సంకేతాలు ఉన్నాయి, కానీ 2 మరియు 3 ఉన్నాయి.
 మీరు విలువలు తనిఖీ 2 సమాన సంకేతాలు ఉపయోగిస్తారు.
 ఇది రకాల తనిఖీ చేయవచ్చు.
 కాబట్టి మీరు మొదటి ఉదాహరణ చూడగలరు ఉంటే,
 నేను num_int == num_string కలిగి.
 కాబట్టి మీ ఉంచడానికి రెండు సాంకేతికంగా, 1,
 కానీ వారు రకాల ఉన్నాము. కానీ డబుల్ సమానం కోసం, ఇది పాస్ చేస్తాము.
 అయితే, ట్రిపుల్ సమానం కోసం, ఇది విలువ అలాగే వివిధ రకాల తనిఖీ.
 అంటే, ఇది ఇక్కడ రెండవ సందర్భంలో పాస్ మాత్రం కాదు అర్థం
 మీరు బదులుగా 3 సమాన సంకేతాలు ఉపయోగిస్తున్నట్లయితే పేరు.
 కాబట్టి మీరు అన్ని ఇప్పుడు చూపించింది వుండాలి ఒక ప్రధాన తేడా ఉంది.
 

స్ట్రింగ్ జోడింపు మీరు PHP లో ఉపయోగించే మరొక శక్తివంతమైన విషయం.
 ఇది ప్రాథమికంగా ఈ సులభ డాట్ సంకేతం
 మరియు మీరు కలిసి తీగలను కట్టుబడి ఎలా.
 కాబట్టి మీరు పిల్లి కలిగి మరియు మీరు డాగ్ కలిగి, మరియు మీరు కలిసి 2 రెమ్మలు చాలు అనుకుంటే,
 మీరు కాలం ఉపయోగించవచ్చు, మరియు ఇది ఎలా ఉంటాము.
 మీరు కూడా కేవలం ఒకదాని తరువాత వాటిని ఉంచవచ్చు,
 మీరు క్రింద ఉదాహరణకు ఇక్కడ చూడగలరు వంటి,
 నేను స్ట్రింగ్ 1, స్పేస్ స్ట్రింగ్ 2 ప్రతిధ్వని పేరు.
 PHP వంటి వాటిని స్థానంలో తెలుస్తుంది.
 వ్యూహాలను. ఇప్పుడు, PHP లో శ్రేణుల యొక్క 2 వివిధ రకాల ఉన్నాయి.
 మీరు సాధారణ శ్రేణుల కలిగి మరియు మీరు కూడా సహయోగ శ్రేణుల కలిగి,
 మరియు మేము వాటిని ద్వారా వెళ్ళడానికి వెళుతున్న.
 రెగ్యులర్ శ్రేణులను ఈ సి లో
 మరియు మీరు లెక్కించబడ్డాయి ఆ సూచీలు కలిగి.
 ప్రస్తుతం మేము సృష్టించాలి వెళ్లి ఉంచారు చేస్తున్నారు -
 ఈ మేము ఒక ఖాళీ శ్రేణి సృష్టించడానికి ఎలా, అప్పుడు మేము చూడాలని
 ఇండెక్స్ సంఖ్య 0 ఉంచి.
 మేము సంఖ్య 6, విలువ 6 ఉంచారు చూడాలని.
 మీరు ఇక్కడ దిగువన చూడగలరు.
 Where's - ఇండెక్స్ సంఖ్య 1 వద్ద మేము, విలువ సంఖ్య 4 పెట్టి చూడాలని
 మరియు మీరు ఒక 6 ఉంది చూడగలరు, ఒక 4, ఉంది
 ఆపై మేము విషయాలు ప్రింటింగ్ వంటి,
 మేము ప్రయత్నించండి మరియు ఇండెక్స్ సంఖ్య 0 వద్ద నిల్వ విలువ ప్రింట్ చేసినప్పుడు,
 అప్పుడు మేము ముద్రించబడ్డాయి 6 విలువ చూస్తారు. కూల్?
 కాబట్టి మీరు కోసం సాధారణ శ్రేణుల ఉంది.
 మీరు కూడా ఇప్పుడు సాధారణ శ్రేణుల విషయాలు మరో మార్గం
 మీరు చివరిలో వాటిని జోడించవచ్చు ఉంది. మీరు నిర్దిష్ట ఇండెక్స్ పేర్కొనాలి లేదు అంటే.
 మీరు సంఖ్య చూడగలరు, మరియు చదరపు బ్రాకెట్లలో పేర్కొన్న ఏ ఇండెక్స్ ఉంది.
 మరియు అది తెలుస్తుంది - PHP కేవలం జాబితా, తదుపరి ఉచిత స్పాట్ ముగింపు జోడించి తెలుస్తుంది.
 కాబట్టి మీరు ఆ 0 స్పాట్ వద్ద అక్కడే 1 చూడగలరు
 2 మొదటి స్థానంలో కుడి వెళ్ళినప్పుడు.
 3 వెళ్తాడు - అలాగే అక్కడ జోడిస్తారు.
 కాబట్టి ఆ రకమైన అర్ధమే. మీరు నిరంతరం ఇది జోడించే,
 మరియు తర్వాత మేము, సంఖ్య 1 యొక్క ఇండెక్స్ ప్రతిధ్వనించే చేసినప్పుడు
 ఇది విలువ 2 ముద్రిస్తుంది.
 

అప్పుడు మేము సహయోగ శ్రేణుల అని శ్రేణుల కలిగి.
 బదులుగా సంఖ్యా సూచీలు కలిగి సహయోగ శ్రేణుల,,
 ఏమి చేసెదరో వారు నవలని అని సూచీలు కలిగి, ఉంది.
 మీరు బదులుగా, చూడగలరు - నేను అన్ని ఆ సంఖ్య సూచీలు తొలగిపోయారు,
 మరియు ఇప్పుడు అది key1, key2, key3, మరియు వారు అన్ని తీగలను అని సూచిస్తుంది డబుల్ కోట్స్ లో ఉన్నాము.
 కాబట్టి మేము ఈ ఒక ఉదాహరణ కలిగి.
 ఈ యొక్క ఉదాహరణ మేము TF కలిగి ఉంది, మరియు ఆ సూచిక పేరు.
 మేము, కేలరీలు తింటారు, సూచిక వద్ద, పేరు "ఆలీ" పెట్టి చూడాలని
 మేము బదులుగా ఒక స్ట్రింగ్ యొక్క ఒక పూర్ణాంకానికి ఈ సమయంలో ఉంచవచ్చు,
 ఆపై ఇండెక్స్ మంది ఇష్టపడ్డారు, మనం లోపల ఒక మొత్త ఉంచవచ్చు.
 కాబట్టి ఈ రకమైన ఉంది - మేము కలిగి ఎలా ఇదే భావన ఉంది
 సంఖ్యలు బొగ్గు దుమారం, కానీ ఇప్పుడు మేము చుట్టూ సూచీలు మార్చవచ్చు
 బదులుగా తీగలను కలిగి ఉంటాయి.
 మీరు కూడా, కేవలం వ్యక్తిగతంగా చేస్తున్న పాటు, చేయవచ్చు
 మీరు ఒక భాగం లో అన్ని చేయవచ్చు. కాబట్టి మీరు, ఆ శ్రేణి యొక్క TF చూడగలరు
 మరియు అప్పుడు మేము ఒక దిగ్గజం చదరపు బ్రాకెట్ సెట్ వాటిని అన్ని సెట్.
 కాబట్టి ఆ విషయాలు వేగవంతం.
 ఇది కాదు ఒక చిన్న అతిపెద్దదైన పొందండి మరింత.
 లూప్ కలిగి.
 సి లో మేము ఈ వంటి ఏర్పాటు చేస్తాము.
 మేము మా శ్రేణి ఉంది, మరియు మేము జాబితా చివర ఇండెక్స్ 0 నుంచి,
 మరియు మేము, అది ప్రింట్?
 , సమస్య సహయోగ శ్రేణుల కోసం, తప్ప
 మేము తప్పనిసరిగా ఆ సంఖ్యా సూచీలు తెలియదు
 ఇప్పుడు మేము స్ట్రింగ్ సూచీలు ఎందుకంటే.
 ఇప్పుడు మేము మళ్ళీ, మీరు ఆశాజనక pset 7 లో ఉపయోగించే, foreach ఉచ్చులు, ఉపయోగించడానికి.
 Foreach ఉచ్చులు జాబితాలో ప్రతి పాట తెలుస్తుంది.
 మరియు మీరు కలిగి ఖచ్చితంగా సంఖ్యా ఇండెక్స్ తెలుసు లేదు.
 కాబట్టి మీరు శ్రేణి ఉంచారు, మీరు foreach వాక్యనిర్మాణం, కాబట్టి ఇది foreach ఉంది.
 , నా అర్రే pset అంటారు, ఆపై వంటి పదం, వంటి
 మరియు మీరు ఉపయోగించడానికి వెళుతున్న ఈ స్థానిక తాత్కాలిక వేరియబుల్ చాలు
 కేవలం నిర్దిష్ట కలిగి వెళుతున్న ఆ నిర్దిష్ట విషయం కోసం -
 ఉదాహరణకు లేదా శ్రేణి యొక్క ఒక విభాగం.
 , Pset num 1 నొక్కి, ఆపై ఉండవచ్చు ఇది సంఖ్య 6 నొక్కి
 ఆపై ఇది సంఖ్య 2 కలిగి ఉంటుంది.
 కానీ శ్రేణి అని ప్రతి విలువ ద్వారా వెళ్ళడానికి హామీ ఉంది.
 మీరు PHP తెలుసుకోవాలి ఉపయోగకరమైన విధులు అవసరమవుతుంది,
 నిష్క్రమణ, ఖాళీ, ప్రతిధ్వని ఆ, మీరు కొన్ని ఫైల్స్ చేస్తున్నారు ఖచ్చితంగా చేస్తుంది.
 నేను అత్యంత మీరు pset 7 చూడండి మరియు ఆ విధులు చూడండి సిఫార్సు.
 మీరు ఆ తెలుసు ఉంటుంది,
 నేను ఖచ్చితంగా ఖచ్చితంగా, ఆ అన్ని ఏమి, తెలుస్తుంది.
 

ఇప్పుడు మేము నిజంగా త్వరగా స్కోప్ ద్వారా వెళుతున్నాం.
 పరిధిలో, PHP, C కాకుండా, ఒక అల్లరిగా విషయం రకం
 అందువలన మేము త్వరగా ద్వారా వెళ్ళి చూడాలని.
 కాబట్టి యొక్క మేము మేము అక్కడ ఆ బాణం వద్ద మొదలు అని పిలవబడు.
 మరియు మేము $ నేను ప్రారంభం చూడాలని. కాబట్టి వేరియబుల్ 'నేను', 0 అని అన్నారు
 మరియు మేము కేవలం అక్కడ పెద్ద తెలుపు బాక్స్ లో ప్రింటింగ్ ఉంచడానికి వెళుతున్న.
 మేము I0 ప్రారంభం చూడాలని, మరియు తర్వాత మేము అది ప్రతిధ్వని చూడాలని.
 కాబట్టి 0 ఉంది.
 మరియు తర్వాత మేము, కోసం లూప్ ద్వారా పెంచడం చూడాలని
 మరియు అది 1 విలువ చేస్తాడు.
 , కంటే తక్కువ 3, కాబట్టి ఇది ఆ లూప్ గుండా వెళుతున్న
 మరియు తర్వాత మేము అది మళ్ళీ ముద్రించిన చూడండి చూడాలని.
 మేము, 2 మళ్ళీ పెంచడం చూడాలని
 మరియు 2 కంటే తక్కువ 3, కాబట్టి ఇది లూప్ పాస్ చేస్తాము, మరియు అది 2 ప్రింట్ చేస్తాము.
 అప్పుడు మీరు 3 3 కంటే తక్కువ కాదు గమనించండి చేస్తాము, కాబట్టి మేము లూప్ బయటకు వస్తుంది.
 కాబట్టి ఇప్పుడు మేము నిష్క్రమించారు తర్వాత, ఆపై మేము కార్య క్షీణత లోకి వెళ్ళి చూడాలని.
 సరే. కాబట్టి మీరు ఈ వేరియబుల్ మేము సృష్టించిన గమనించండి ఉంటుంది
 'నేను' వేరియబుల్, స్థానికంగా దర్శిని గల లేదు.
 అది లూప్ స్థానిక కాదు అర్థం,
 మరియు ఆ వేరియబుల్ మేము ఇంకా యాక్సెస్ మరియు తరువాత మార్చడానికి, మరియు ఇది ఇప్పటికీ ప్రభావవంతంగా చేయవచ్చు.
 మీరు ఇప్పుడు ఫంక్షన్ వెళ్ళాలని అలా, మీరు, మేము కూడా 'నేను' వేరియబుల్ ఉపయోగించే చూస్తారు
 మరియు మేము 'నేను' + + పెంచడం చూడాలని.
 ఆ 'నేను' వేరియబుల్ కాపీని అని, సి ఆధారంగా, మొదటి వద్ద, అనుకుంటున్నాను.
 ఇది సరైనది, ఒక విభిన్నమైన విషయం.
 మేము ప్రింట్ చేసినప్పుడు, మేము ప్రింట్ అన్నారు ఇది, 'నేను' + + ప్రింట్ వెళుతున్న 4,
 క్షమించాలి - మరియు తర్వాత మేము చూడాలని.
 తర్వాత ఆ పనితీరు ముగింపు వెళుతున్న చేస్తున్నాం,
 మరియు మేము ఆ బాణం జగన్ను మాత్రం.
 ఆ తర్వాత, అయితే, ఫంక్షన్ 'నేను' విలువ మార్చారు ఉన్నప్పటికీ అర్థం,
 పదికి ఫంక్షన్ లేదు,
 ఫంక్షన్ ఒక ప్రత్యేక పరిధిని కలిగి.
 అంటే 'నేను' echo, అది ఫంక్షన్ యొక్క పరిధిని మార్చలేదు అర్థం
 , అందువలన మేము మళ్ళీ 3 ప్రింట్ చూడాలని.
 C. కంటే PHP లో అవకాశాలపై వివిధ విషయాలు 

ఇప్పుడు PHP మరియు HTML లో.
 PHP వెబ్ పేజీలు డైనమిక్ చేయడానికి ఉపయోగిస్తారు.
 ఇది రకం విషయాలను వివిధ చేస్తుంది.
 మేము HTML నుండి వివిధ కలిగి.
 HTML తో, మేము ఎల్లప్పుడూ, రాబ్ చూపించింది ఎలా వంటి అదే స్టాటిక్ విషయం కలిగి
 PHP అయితే, మీరు యూజర్ అయిన ఆధారంగా విషయాలు మార్చవచ్చు.
 నేను ఈ కలిగి ఉంటారు, నేను, "మీరు వలె లాగిన్ -" మరియు తర్వాత పేరు,
 మరియు నేను మార్చవచ్చు. కాబట్టి ప్రస్తుతం పేరు, జోసెఫ్ ఉంది
 మరియు అది ", నా గురించి" ఉంది కానీ నేను కూడా టామీ కలిగి మార్చవచ్చు.
 మరియు ఆ వేరే విషయం ఉంటుంది.
 కాబట్టి అప్పుడు మేము కూడా అతని గురించి వివిధ విషయాలను మార్చవచ్చు,
 మరియు దానిని బట్టి కంటెంట్ చూపిస్తుంది.
 కాబట్టి PHP రకమైన మీ వెబ్సైట్ లో ఏమి మార్చవచ్చు.
 ఇక్కడ అదే. ఇప్పటికీ, వారు వివిధ కంటెంట్ గమనించండి,
 మీరు సాంకేతికంగా ఇప్పటికీ ఉపరితలంపై అదే వెబ్ పేజీ యాక్సెస్ అయినప్పటికీ.
 HTML ఉత్పత్తి. మీరు దీన్ని చేయవచ్చు 2 మార్గాలు ఉన్నాయి.
 కాబట్టి మేము ఇప్పుడు ఆ ద్వారా వెళ్తారో. మొదటి మార్గం మీరు, ఉంది - ఓహ్, సారీ.
 కాబట్టి మీరు, PHP లో లూప్ మీ సాధారణ కలిగి
 మరియు మీరు PHP లో ప్రతిధ్వని మరియు మీరు HTML ఎకో.
 రాబ్ HTML స్క్రిప్ట్ మీరు చూపించారు ఏమి ఉపయోగించి
 ఆపై కేవలం వెబ్ పేజీ దానిని ప్రింట్ PHP print ఉపయోగించి.
 ప్రత్యామ్నాయ మార్గం మీరు PHP మరియు HTML వేరు ఉంటే దీన్ని ఉంది.
 కాబట్టి మీరు, లూప్ ప్రారంభమయ్యే PHP ఒక లైన్ చేయవచ్చు
 అప్పుడు మీరు ఒక ప్రత్యేక విషయం లో HTML యొక్క లైన్ కలిగి,
 ఆపై మీరు ఒక PHP తో, మళ్ళీ, లూప్ ముగుస్తుంది.
 కనుక ఇది రకమైన వేరుచేసి యొక్క.
 ఎడమ వైపున, మీరు కలిగి అన్ని -
 ఇది PHP కేవలం 1 భాగం ఉంది.
 కుడివైపు మీరు, మీరు PHP ఒక లైన్ ఆ చూడగలరు
 మీరు HTML యొక్క ఒక లైన్ కలిగి, మరియు మీరు మళ్ళీ PHP ఒక లైన్.
 కాబట్టి వారు చేస్తున్న లోకి దాన్ని వేరు.
 మరియు మీరు ఆ మార్గం, వాటిలో గాని కోసం, గమనించండి చేస్తాము
 వారు ఇప్పటికీ చిత్రం ప్రింట్, చిత్రం, చిత్రం,
 కాబట్టి HTML ఇంకా అదే విధంగా ముద్రించబడుతుంది.
 ఆపై మీరు ఇప్పటికీ 3 చిత్రాలు మీ వెబ్ సైట్ లో ప్రదర్శించబడవు చూస్తారు.
 కనుక ఇది అదే పనిని 2 వివిధ మార్గాలు.
 

ఇప్పుడు మేము రూపాలు మరియు అభ్యర్థనలు. రాబ్, మీరు చూపించారు
 అక్కడ HTML యొక్క రూపాలు, మరియు మేము ఈ పడుతారు ఉంటుంది.
 మీరు ఒక చర్య మరియు మీరు ఒక పద్ధతి, మరియు మీ చర్య
 రకమైన మీరు పంపించండి వెళుతున్న చూపుతుంది, మరియు పద్ధతి అని
 ఇది ఒక GET లేదా ఒక POST చేస్తాడు.
 మరియు ఒక కాబట్టి, చెప్పారు వంటి, మీరు ఒక రూపంలో ఉంచారు చూడాలని అర్థం
 ఒక POST అభ్యర్థనను మీరు ఒక URL లో చూడరు అయితే మరియు మీరు, ఒక URL ఇది చూస్తారు.
 కాబట్టి కొద్దిగా తేడా.
 అయితే, ఇదే విషయం అని ఒక విషయం
 POST మరియు GET సమానంగా అసురక్షిత అని.
 కాబట్టి మీరు, కనుక మీరు URL లో చూడండి లేదు అనుకోవచ్చు
 ఆ, POST ఎక్కువ సురక్షితమైనది అర్థం
 కానీ మీరు ఇంకా మీరు పంపే చేస్తున్న సమాచారాన్ని మీ కుకీలను లో చూడవచ్చు.
 కాబట్టి ఆ భావించడం లేదు గురించి ఒకటి లేదా ఇతర.
 గమనించదగ్గ మరో విషయం మీరు కూడా విభాగంలో వేరియబుల్స్ కలిగి ఉంది.
 మీరు అబ్బాయిలు మీ యూజర్ ID సమాచారం పొందడానికి pset 7 లో ఈ ఉపయోగించారు.
 ఏమి జరిగింది మీరు ఈ అనుబంధ శ్రేణి ఉపయోగించే ఉంది,
 $ _ సెషన్, మరియు మీరు వివిధ విషయాలు ప్రాప్తి చూడగలరని
 మరియు పేజీలు అంతటా వివిధ విషయాలు నిల్వ.
 

చివరి విషయం, మేము SQL, నిర్మితీకృత ప్రశ్నా భాష కలిగి ఉంది
 మరియు ఈ డేటాబేస్ నిర్వహించడానికి ఒక ప్రోగ్రామింగ్ భాష.
 , ఖచ్చితంగా, డేటాబేస్ ఏమిటి? వారు పట్టికలు సమాహారం ఉన్నారు,
 ప్రతి పట్టిక వస్తువుల ఏకరూప ఉండవచ్చు.
 కాబట్టి మేము మీ ఆర్థిక pset లో వినియోగదారుల ఒక పట్టిక కలిగి.
 మరియు ఎందుకు వారు ఉపయోగకరం? అది శాశ్వతంగా సమాచారాన్ని నిల్వ ఒక మార్గం ఎందుకంటే.
 ఇది విషయాలు ట్రాకింగ్ మరియు విషయాలు నిర్వహించడం మార్గంగా ఉంది
 మరియు నిజానికి వేర్వేరు పేజీల మరియు కీపింగ్ ట్రాక్ చూసిన.
 అయితే మీరు కేవలం ఒక తక్షణ సమయంలో నిల్వ ఉంటే
 ఆపై తర్వాత దాన్ని ఉపయోగించవచ్చు, మీరు సేవ్ చేసిన ఏదైనా యాక్సెస్ చెయ్యడానికి చేయలేరు.
 మేము SQL ఆదేశాలను కోసం ఉపయోగించే 4 ప్రధాన విషయాల్లో.
 మేము ఎంచుకోండి చొప్పించు, తొలగించండి మరియు నవీకరణ.
 ఆ మీరు అబ్బాయిలు మీ క్విజ్ తెలుసు కోసం ముఖ్యమైనవి.
 

మేము త్వరగా చేతికి ఎన్నుకుంటే వెళ్తారో.
 సాధారణంగా, మీరు ఒక డేటాబేస్ దీన్ని ఉంది.
 కాబట్టి మీరు ఇక్కడ, ఉంటే -
 మేము ఈ 2 వివిధ విషయాల్లో, మరియు మేము తరగతులు పట్టిక నుండి ఎంచుకోండి
 పేరు అద్భుతంగా - అద్భుతంగా కాలమ్ విలువ 1 ఉంటుంది.
 మీరు ఇక్కడ చూడగలరు, మేము, తరగతి పేరుతో ఈ 2 విషయాల్లో
 CS50 మరియు Stat110, మరియు మేము తరగతి ID లు మరియు నినాదం కలిగి.
 కాబట్టి మేము ఆ సమాచారాన్ని ఎంచుకోండి.
 అప్పుడు మీరు, అది రకమైన అద్భుతంగా కాలమ్ బయటకు ఎంపికలో ఇక్కడే చూడగలరు
 అన్ని విషయాలు 1, తరువాత అది తరగతి ID, తరగతి పేరు మరియు దాన్ని ఎంచుకోవచ్చు ఆ నినాదం ఉంది పేరు.
 మీరు ఈ కోడ్ లో ఎలా చేస్తారు? అవును ఉంటుంది.
 కాబట్టి ఆ రకమైన PHP మరియు SQL ప్రతి ఇతర సంబంధించిన ఎలా.
 ఇప్పుడు మేము మా కోడ్ కలిగి, మరియు మేము మా ప్రశ్న ఫంక్షన్ ఉపయోగించడానికి వెళుతున్న
 మేము pset 7 లో చేశాడు, మరియు మేము SQL ప్రశ్న అమలు చూడాలని.
 అప్పుడు మేము చూడాలని -
 మేము ఎల్లప్పుడూ తప్పుడు ఉంటే వరుసగా త్రివిధ సమాన అయితే తనిఖీ. మరలా, మీరు రకం మరియు విలువ తనిఖీ,
 ఇది పని చెయ్యకుండా ఆపై, మీకు మేము pset 7 లో వలె, సాధారణ గా, క్షమాపణలు చెబుతానన్నారు.
 లేకపోతే, మీరు ఆ సులభ తో ప్రతిదీ ద్వారా లూప్ కావలసిన
 foreach మేము కేవలం వెళ్లిన ఉచ్చులు.
 , మేము ద్వారా మళ్ళీ వెతికినా మరియు మేము గత ఇది చేసిన ఇప్పుడు ఆ
 యొక్క మా ప్రశ్న జారీ భావించేందుకు వీలు, ఇప్పుడు మేము మా foreach లూప్ ఉన్నాయి.
 అంటే, ఉంది, ఇక్కడ వరుసగా ఇక్కడే, ఉంది ఇది బాక్స్ యొక్క.
 ఇది సంపాదించిన అన్ని సమాచారం ప్రింట్ వెళుతున్న.
 కనుక ఇది దిగువన ప్రింట్ వెళుతున్న "వన్నా HTML తెలుసుకోండి?"
 ఇది మొదటి లూప్ పూర్తి ఎందుకంటే అప్పుడు,, తదుపరి వరుస వెళ్ళండి వెళుతున్న
 కాబట్టి అప్పుడు ఇది, ఇది రెండవ లైన్ ప్రింట్ వెళుతున్న
 STAT110 అన్నారు ఇది, అన్ని మూమెంట్స్ కనుగొను.
 

ఒక చివరి విషయం SQL డిస్ప్లే ఉంది.
 నేను డేవిడ్ ఈ ఉపన్యాసంలో కొద్దిగా తాకిన తెలుసు.
 మీరు ఈ చదువుకోవచ్చు. ఇది నిజంగా సరదాగా అనిపిస్తుంది.
 SQL ఇంజెక్షన్ గమ్మత్తైన విషయం ఒక రకం.
 యొక్క మీరు కేవలం మీ ప్రశ్న లోకి ఆ వేరియబుల్స్ కర్ర అని పిలవబడు,
 మీరు ఆ మొదటి లైన్ లో చూడగలరు గా.
 కాబట్టి అది కుడి, జరిమానా ఉంది? మీరు కేవలం యూజర్ పేరు లో ఉంచడం చేసిన
 మరియు మీ SQL ప్రశ్న పాస్వర్డ్ మరియు మీరు ఇది ఆఫ్ ఓడ మరియు మీ డేటా పట్టిక లో సంసార పొందాలనుకోవడం.
 ఆ అందమైన సాధారణ కనిపిస్తుంది. కాబట్టి, ఎవరైనా లో ఉంచుతుంది చెప్పడానికి అనుమతిస్తుంది
 పాస్వర్డ్ను కోసం, ఈ OR టెక్స్ట్ ఇక్కడే -
 నిజానికి ఎరుపు బాక్స్ లో ఉండాలి.
 కాబట్టి యొక్క వారు ఆ పాస్వర్డ్ను ఉంచండి అని పిలవబడు - వారు ఎంటర్ ఏమిటి.
 కాబట్టి వారు ఉంచడం OR "1" = 1 చేస్తున్నారు.
 కలిగి ఒక వెర్రి పాస్వర్డ్ను రకం.
 ఇప్పుడు కేవలం అది స్థానంలో తెలియజేయండి మరియు మీరు ఇప్పుడు SQL ప్రశ్న లో గమనించండి చేస్తాము,
 మీరు గమనించండి చేస్తాము ఎందుకంటే, ఎప్పుడూ నిజం కు మదింపు
 మీరు SQL ప్రశ్న ఈ సమాచారం అన్ని ఎంచుకోవచ్చు
 లేదా మీరు = 1 1 ఉండవచ్చు.
 కాబట్టి ఆ ఎల్లప్పుడూ నిజమైన విశ్లేషించదు చేస్తాడు.
 మొదట వ్యవస్థ విచ్ఛిన్నం చేసే అర్థం ఎందుకంటే, నిజంగా పని మాత్రం కాదు.
 ఈ పరిష్కారం మీరు PDO వ్యవస్థ ఉపయోగించడానికి కలిగి ఉంది,
 ఇది, మీరు ప్రశ్నార్థకాలుగా ఉపయోగించాలి అర్థం
 మీరు pset 7 ఉపయోగిస్తారు అబ్బాయిలు, ఇది
 మీరు ఏదో ఉంచాలి కావలసిన ఉన్న స్థానంలో ప్రశ్నార్ధకం ఉపయోగించడానికి వెళుతున్న,
 మరియు, మీరు కామాతో చూడాలని, ఆపై మీరు తర్వాత ఉంటుంది
 మీ స్ట్రింగ్ తర్వాత, మీకు కావలసిన వివిధ వేరియబుల్స్ మీ ప్రశ్న గుర్తు లోకి స్థానంలో.
 కాబట్టి మీరు ఇప్పుడు నేను ఈ ఎరుపు ప్రశ్నార్థకాలుగా కలిగి ఇక్కడ గమనించండి చేస్తాము.
 నేను తర్వాత చేసుకున్నంతసేపూ స్థానంలో తెలుసు కాబట్టి అప్పుడు నా తీగలను తరువాత వేరియబుల్స్ ఉంచండి.
 ఎవరైనా ఈ వంటి అది ఉంటే ఆ, ఖచ్చితంగా ఆ చేస్తుంది
 మరియు వారు, ఖచ్చితంగా చేస్తుంది, లేదా 1 = 1 పరిస్థితి కలిగి
 తిరిగి చివరికి, ఇది వాస్తవానికి SQL ప్రశ్న బ్రేక్ లేదు నిర్ధారించుకోండి.
 సరే, PHP మరియు SQL సుడిగాలి, ఇది చాలా కాబట్టి.
 మీరు అన్ని శుభాకాంక్షలు, మరియు ఇప్పుడు Ore. కు
 

[Oreoluwatomiwa Babarinsa] సరే అందరికీ. కొన్ని జావాస్క్రిప్ట్ వెళ్ళి సమయం
 మరియు కొన్ని ఇతర విషయాలు చాలా త్వరగా కాబట్టి మీరు టునైట్ పట్టుకొని లేదు.
 జావాస్క్రిప్ట్. అవును. జావాస్క్రిప్ట్ ఉద్దేశ్య, ఒక చల్లని విషయం రకంగా ఉంది.
 మీరు నిజంగా JavaScript గురించి తెలుసుకోవాలి విషయాలు, అది విధమైన వంటిది
 మీ వెబ్ అప్లికేషన్ చేస్తూ అన్నారు ఏమి క్లైంట్ వైపు ముగింపు.
 మీరు సర్వర్ వైపు అన్ని సమయం యొక్క శ్రద్ధ వహించడానికి లేదు కొన్ని విషయాలను.
 అన్ని చిన్న పరస్పర,, ఒక విషయం చూపిస్తున్న ఏదో అదృశ్యం తయారు.
 మీరు నిజంగా మీ సర్వర్కు కోసం అన్ని సమయం మాట్లాడటానికి కలిగి వద్దు.
 మరియు ఆ కొన్ని సర్వర్లో చేయడానికి కూడా సాధ్యం కాదు.
 మేము JavaScript వంటి ఏదో అవసరం ఎందుకు ఉంది.
 జావాస్క్రిప్ట్ గురించి విషయాలు: ఇది డైనమిక్ టైపు చేసినప్పుడు.
 ఈ మీ కార్యక్రమం తెలుసుకోవాలి ఉండదు
 మీరు దీనిని వ్రాస్తున్నప్పుడు ఏమి, ఖచ్చితంగా, వేరియబుల్స్ ఉన్నాయి.
 ఇది అమలు ఇది కేవలం విధమైన అది కనిపెడతాడు.
 దాని గురించి చల్లని అని ఇతర విషయాలు: ఇది ఒక వంకర కలుపు భాష,
 వాక్యనిర్మాణం సి మరియు PHP పోలి ఉంటుంది అర్థం.
 మీరు జావాస్క్రిప్ట్ నేర్చుకుంటున్నారు చాలా మరల పని చేయడానికి లేదు.
 ఇక్కడ మేము JavaScript కొద్దిగా ఉన్నాయి.
 ఇక్కడే ఆసక్తికరమైన విషయం, మీరు చూడండి ఉంటే, ఉంది
 మేము తల ట్యాగ్ లో అక్కడే జావాస్క్రిప్ట్ ఒక బిట్ కలిగి.
 ఏమిటి కేవలం ఒక JavaScript ఫైలు ఉన్నాయి ఇది ఉంటుంది.
 ఈ మీరు మీ కార్యక్రమంలోకి జావాస్క్రిప్ట్ ఉంటాయి ఒక మార్గం.
 అప్పుడు రెండవ కొద్దిగా, నిజానికి కొన్ని ఇన్లైన్ జావాస్క్రిప్ట్ ఉంది
 చాలా CSS ఒక ఇన్లైన్ శైలి పోలి,
 మరియు మీరు కేవలం చాలా త్వరగా అక్కడ కొన్ని కోడ్ రాస్తున్నాం.
 జావాస్క్రిప్ట్ శ్రేణుల ఉంది.
 చాలా ఉపయోగకరంగా, చుట్టూ డేటా ఉంచడానికి మరొక మార్గం.
 చాలా అవును.
 మీరు ప్రతి యాక్సెస్ మరియు కలిసి ప్రతిదీ ఉంచడానికి చదరపు బ్రాకెట్లలో ఉపయోగించండి.
 చాలా క్లిష్టమైన ఏమీ.
 సాధారణంగా JavaScript మరియు స్క్రిప్టింగ్ భాషలు గురించి చల్లని విషయం
 మీరు శ్రేణి పరిమాణాలు గురించి ఆందోళన లేదు అని.
 మీరు array.length దాని యొక్క ట్రాక్ చేయవచ్చు,
 మరియు శ్రేణి పెరిగే లేదా మీరు ఇది అవసరం కుదించగలరని.
 సో మీరు కూడా, ఏ విధమైన గురించి ఆందోళన అవసరం లేదు
 అరెరే, నేను మరింత విషయాలు, లేదా ఆ వంటి ఏదైనా కేటాయించాల్సిన అవసరం.
 

ఇక్కడ చల్లని విషయం జావాస్క్రిప్ట్ వస్తువులు అని ఏదో ఉంది. ఇది ఒక ఆబ్జెక్ట్ ఆధారిత భాష, కాబట్టి ఇది ఏమి, ముఖ్యంగా,
 సమూహం డేటా మిమ్మల్ని కోసం ఒక మార్గం కలిసి, ఒక struct కొంతవరకు పోలి,
 కానీ మీరు ఒక struct వంటి లేదా ఒక అనుబంధ శ్రేణి వాక్యనిర్మాణంలో అది యాక్సెస్ చేయవచ్చు.
 ఇది చాలా సులభం మరియు మీరు ఈ తో చేయవచ్చు కలిసి సమూహం డేటా ఉంది
 మీరు సంబంధించిన ఆ డేటా కొంత ఉంటే.
 మీరు ఒక కారు కలిగింది అన్ని విషయాలు ఎందుకంటే,
 మీరు వివిధ ప్రాంతాల కొంత లో కలిగి అవసరం లేదు.
 మీరు జావాస్క్రిప్ట్ లో 1 వస్తువు అతుక్కుపోగలవు.
 మీరు బహుశా తెలిసి, iterating ఆ దుర్భర పనులు ఒకటి.
 మీరు మళ్ళీ ఒక మీద చేస్తున్నాయి. మీరు, కారులో ప్రతి వస్తువు మాట్లాడటానికి అవసరం
 లేదా మీరు జాబితా లేదా అలాంటిదే లో ప్రతి అంశం ద్వారా వెళ్లాలి.
 కాబట్టి JavaScript, PHP, ఒక foreach వాక్యనిర్మాణం పోలి ఉంది.
 ఈ సందర్భంలో, అది లూప్ లో కోసం ఒక ఉంది.
 మీరు వస్తువులు ఈ ఉపయోగించాలనుకుంటున్నాను.
 మీరు శ్రేణులపై ఈ ఉపయోగిస్తే సంభవించే కొన్ని సమస్యలు ఉన్నాయి.
 ఇది సాధారణంగా, అయితే, చాలా ఉపయోగపడుతుంది, ఆ విషయాలు ఒకటి
 మీరు భారాన్ని చాలా తొలగించడానికి ఎందుకంటే
 మీరే ద్వారా మీ వస్తువు ప్రతిదీ అప్ లాగండి ఉంటుంది లేదు ఎందుకంటే.
 మీరు అన్ని కీ పేర్లు గుర్తు లేదు.
 మీరు విధమైన ఈ వాక్యనిర్మాణంలో వాటిని తిరిగి.
 ఈ లో, కోసం, మీరు కేవలం గుర్తు
 మీరు పట్టిక హాష్ ఒక చాలా విధంగా, అన్ని కీలను తిరిగి పొందుతుంటే.
 మీరు ఆ నుండి గుర్తుంచుకుంటే మీరు ఒక స్ట్రింగ్ లో ఉంచుతాడు, మీరు ఏదో అవుట్ కాలేదు
 దానితో ఒక విలువ వుంటుంది.
 మీరు ఈ తో చేయవచ్చు, మీరు, అన్ని కుడి చెప్పగలను ఉంది
 నేను కారు ఉంచారు, మరియు నేను ఒక ఫెరారీ అని.
 కాబట్టి మీరు తర్వాత మళ్ళీ స్ట్రింగ్ ఫెరారీ లో ఉంచవచ్చు, మరియు మీరు ఆ పొందవచ్చు.
 మరియు మీరు లూప్ లో కోసం తో, ఒక లూప్ లో ఆ చేయవచ్చు.
 కాబట్టి కేవలం వస్తువులు గురించి మరింత. మీరు గుర్తుంచుకోవాల్సిన అవసరం ఈ నుండి కీ విషయం
 , మీరు ఈ తో కావలసినప్పుడు వాక్యనిర్మాణం వంటి వస్తువు struct ఉపయోగించే ఉంది
 మీ స్ట్రింగ్ ఉపయోగించడానికి వెళుతున్న ఒక చెల్లుబాటు అయ్యే చరాంశం పేరు ఉంటే తప్ప.
 మీరు ఆ అక్కడ చూడండి అలా అయితే, మేము ఫైళ్ళను తెరవడానికి.
 సరే, మీరు object.key ఉంచాలి ఉన్నట్లయితే, స్పేస్, తో, స్పేస్, స్పేస్,
 కేవలం పదము అర్ధవంతం లేదు.
 కాబట్టి మీరు బ్రాకెట్ సింటాక్స్ ఈ విధమైన ఆ చేయవచ్చు.
 

కూడా, జావాస్క్రిప్ట్ చాలా పరిధిని వారీగా PHP ఉంది.
 మీరు పరిధిని కొరకు 2 మార్గాలు ఉన్నాయి.
 మీరు ఒక వేరియబుల్ ముందు var ఉండకూడదు,
 మరియు కేవలం ఈ ప్రపంచ అర్థం.
 మీరు ఎక్కడి నుండి చూడగలరు. మీరు ఒక ప్రకటన ఉంటే ఈ ఉంచాలి కూడా,
 ఎక్కడైనా మీ కోడ్ లో ఆ తరువాత మీరు ఆ వేరియబుల్ చూడవచ్చు.
 మరో విషయం, అయితే, అది మీరు సైన్ ఉన్నారు సంసార ఫంక్షన్ పరిమితం, var తో ఉంది
 మీరు ఒక ఫంక్షన్ లో లేదు అయితే, బాగా, అది ప్రపంచ వార్తలు.
 మీరు ఒక ఫంక్షన్ లో ఉంటే కానీ ఆ ఫంక్షన్ లో మాత్రమే కనిపిస్తుంది.
 అవును, ఒక ఉదాహరణ, కానీ లేదు. ఇది ఆ విషయాలు ఒకటి పేరు
 మీరు, మీరు ప్రపంచ ఉండాలనుకుంటున్నాను ఏమి వేరియబుల్స్ నిర్వహించవచ్చు
 ఏ వేరియబుల్స్ మీరు స్థానిక ఉండాలనుకుంటున్నాను, కానీ మీరు ఈ గురించి జాగ్రత్తగా చేయాలి,
 మీరు C లో సన్నని రేణువు నియంత్రణ రకం లేదు ఎందుకంటే,
 ఏదో లూప్ ఒక లో ప్రకటిస్తారు కాబట్టి, ఇది ఆ లూప్ లో ఉండడానికి వెళుతున్న పేరు.
 అంటే కోసం స్కాన్ ఉపయోగించి శ్రద్ధ విషయం కుడి, వెబ్ పేజీలు రెట్టింపు ఉంది?
 నేను అర్థం, ఎందుకు మేము ఇలా ఉంది.
 

మేము DOM అనే ఉపయోగించడానికి, ఆ చేయుటకు.
 డాక్యుమెంట్ ఆబ్జెక్ట్ మోడల్.
 సాధారణంగా, ఏమిటి అది అన్ని మీ HTML పడుతుంది
 మరియు ప్రతి ఇతర లోపల యున్న ఆ వస్తువులు కొంత నమూనాలు దాన్ని.
 మీరు ఈ వంటి ఏదో తో ప్రారంభమై.
 మీరు అక్కడ కోడ్ కొంత విధమైన ఉంది, నాకు కుడి, కలిగి -
 ఆ సవరించడానికి చాలా కష్టం భావిస్తున్నాను,
 మీరు టెక్స్ట్ కొంత ద్వారా పార్సింగ్ అంటాను ఎందుకంటే
 మరియు విషయాలు కాకుండా ముక్క కలిగి. మరియు అది సరిగ్గా ఏమి ఫార్మాట్ ఉంటే?
 చెడు విషయాల జరుగుతుంది.
 కాబట్టి, JavaScript మీరు ఈ జాగ్రత్త తీసుకుంటుంది, మీరు ఒక nice డేటా నిర్మాణం పొందండి
 మీరు ఒక పత్రాన్ని నా, ఎడమ ఒక వంటి,
 మరియు ఆ లోపల మీరు, HTML అనే విషయం
 మరియు ఆ లోపల మీరు, ఒక తల మరియు శరీరం
 మరియు ఆ తల లోపల మీరు, మొదలగునవి, మొదలగునవి మొదలగునవి శీర్షిక.
 ఈ, అది కేవలం కాబట్టి ఒక వెబ్ పేజీ రెట్టింపు సులభతరం
 ఓహ్, నేను కేవలం ఈ వస్తువు మాట్లాడు.
 మీరు మీరే తయారు మరొక వస్తువు మాట్లాడిన చాలా విధంగా విధమైన.
 నేను అన్నాడు వంటి, అన్ని DOM డాక్యుమెంట్ ఆబ్జెక్ట్ లో ఉంది.
 గాని, ఇది కేవలం ఒక స్థానం మరియు మీరు విషయాలు కనుగొనేందుకు దానిలోని వెళ్ళే
 మరియు మీరు దీన్ని చెయ్యవచ్చు - ఈ అక్కడికి, అది చేయడం పాత శైలి,
 మీరు document.getElementById చేయండి, మరియు ఆపై పేరు,
 మీరు బహుశా వర్తమాన మరియు, ఈ ఒక తర్వాత చాలా అతిపెద్దదైన గెట్స్.
 కాబట్టి మీరు బహుశా అలా చేయకూడదని. మేము ఎందుకు పేర్కొంది
 మేము ఈ తరువాత మాట్లాడటానికి చూడాలని తర్వాత విషయం.
 ఇక్కడ కీ విషయం, అన్ని కుడి, మీరు కుడి, ఈ అంశాలను కలిగి?
 కాబట్టి నేను పేజీ లోడ్ ఏదో యొక్క రంగు మార్చవచ్చు.
 కాబట్టి ఏమి? నా యూజర్ ఏదో క్లిక్ ఉంటే?
 నేను వారు ఏదో క్లిక్ చేసినప్పుడు అది ఆసక్తికరంగా చేయాలని.
 మేము సంఘటనలు ఎందుకు పేర్కొంది. మీరు, ప్రాథమికంగా, మీ DOM లో ఏ మూలకం పొందవచ్చు,
 ఆపై హే, చెప్పటానికి. , ఈ లోడుచేస్తుంది లేదా ఎవరైనా అది క్లిక్ చేసినప్పుడు
 లేదా వారు దాని పై మౌస్, దానితో ఏదో చేసినప్పుడు.
 మరియు మీరు కలిగి మీరు ఈ కూర్పులో విధులు, ఉంది.
 ఈ విధులు ఈవెంట్ నిర్వహించే ఉంటాయి.
 ఏ they're - ఇది మాట్లాడుతూ ఒక ఫాన్సీ మార్గం,
 ఈ కార్యక్రమం జరిగినప్పుడు ఈ మాత్రమే అమలు.
 కనుక ఇది హుర్రే.
 మీరు కార్యక్రమం నిర్వహణ బద్ధం ఎలా ఉంది.
 నేను కొన్ని బటన్, మరియు మీరు క్లిక్ చేసినప్పుడు, అది పేలుడు.
 కాబట్టి బటన్ క్లిక్ లేదు.
 ఈ కుడి, సమీపించే ఒక మార్గం?
 , మీరు ఒక బటన్ ట్యాగ్ మరియు క్లిక్ మీరు అని ఒక స్ట్రింగ్ కలిగి
 ఓహ్, మార్గం ద్వారా, నేను నాకు ఈ పేలే పనిని.
 లేకపోతే, అది కేవలం మీరు చేసిన ఒక సాధారణ బటన్ వంటిది.
 మీరు కూడా ఈ మరొక మార్గం చేయవచ్చు,
 మేము క్వెరీ గారు DOM మూలకం ఈడ్చడం కానీ ద్వారా ఆ సేవ్ చేస్తాము.
 

J క్వెరీ: ఇది క్రాస్ బ్రౌజర్ ఒక గ్రంథాలయం.
 మీరు గొప్పది ఏదైనా దానిని ఉపయోగించవచ్చు.
 ఇది మీరు పని సాధనాలు చాలా ఇస్తుంది.
 జావాస్క్రిప్ట్, శక్తివంతమైన అయితే, మీరు అవసరం అన్ని టూల్స్ లేదు ఎందుకంటే
 నిజంగా ఒక వెబ్ అనువర్తనం పరిష్కరించడానికి బాక్స్ బయటకు మీరు అనుకోవచ్చు.
 కనుక ఇది, విషయాలు చాలా సులభతరం మీరు విధులు చాలా ఇస్తుంది
 మీరు సాధారణంగా మళ్ళీ మరియు పైగా మరియు పైగా, మీరే రాయడానికి అని బాక్స్ బయటకు.
 మరియు కేవలం విషయాలు చాలా సులభం చేస్తుంది.
 మీరు అన్ని అంశాలను చేద్దామని వీలు ఇది సెలెక్టర్లు, కలిగి
 మీ DOM మరింత నుండి కేవలం, బదులుగా ఈ చాలా ఫంక్షన్ కాల్స్ ఉపయోగించడానికి అవసరం.
 ఈ సెలెక్టర్లు మరింత. మీరు, సే తెలియజేయండి చేశారు అక్కడికి, కలిగి
 నేను ID తో ఒక మూలకం మీరు, "రాక్."
 బాగా, j క్వెరీ లో, అది కేవలం $ ఆపై ఒక పౌండ్ ఉంది ఒక స్ట్రింగ్, మరియు ఉంది "రాక్."
 ఇది చాలా సులభమైన మరియు ఈ సమస్య పరిష్కారంలో సంప్రదాయ జావాస్క్రిప్ట్ మార్గం కంటే చాలా వేగంగా ఉంది.
 మరియు మీరు తరగతులు మరియు మూలకం రకాల కోసం విషయాలు కలిగి.
 j క్వెరీ ఉంది - అద్భుతమైన ఒకటి మీరు విధమైన కుదించవచ్చు ఉంది
 మీ DOM మీ ప్రశ్నలు డౌన్ చాలా, చాలా వేగంగా.
 ఇప్పుడు మేము తిరిగి ఈవెంట్ నిర్వహణ ఉన్నాము, మరియు ఈ మీరు j క్వెరీ లో ఒక సంఘటన నిర్వహించడానికి ఎలా ఉంది.
 కాబట్టి మనం ఇక్కడ చూడాలని మేము అన్ని కుడి, చెబుతున్న ఉంది. నేను స్క్రిప్ట్ ట్యాగ్ కలిగి, కుడి?
 నేను స్ట్రింగ్ argv.
 మనం చేయబోతున్నామని మేము అన్ని కుడి, చెప్పడానికి వెళుతున్న ఉంది.
 పత్రం, పత్రం లోడ్ చెయ్యబడిన అంటే, సిద్దంగా ఉన్నప్పుడు
 , మేము ఆ ఫంక్షన్ కు వెళ్ళి, మరియు మేము, అన్ని కుడి చెప్పటానికి చూడాలని
 ఈ ఫంక్షన్ వాస్తవానికి ఏదో చేయుచున్నాడు.
 ఇది ప్రాథమికంగా అన్ని కుడి, నాకు ID తో మూలకం పొందడానికి, మాట్లాడుతూ "myid."
 మరియు ఈ మీరు క్లిక్ చేసినప్పుడు అమలు చేసే ఒక ఫంక్షన్ నిర్వహణ ఇవ్వాలని.
 సాధారణంగా ఈ చేస్తుంది, అది, అన్ని హక్కు.
 , పేజీ లోడ్, నేను లో, ఈ మూలకం కనుగొనేందుకు వెళుతున్న
 ఈ కార్యక్రమం నిర్వహణ ఇవ్వాలని మరియు ఇది ప్రాథమికంగా మీరు కోసం మీ పేజీ సెట్స్ అప్.
 ఇది నిజంగా నిర్వహణ గురించి ఆలోచించటం ఎలా ఉంది.
 మీరు కేవలం, ఆలోచించడానికి అన్ని కుడి, ఏదో సంభవించినప్పుడు, నేను జరిగే ఏమి అనుకుంటున్నారు?
 మీరు, సరే, నేను ఈ విషయం ఖచ్చితంగా ఈ విషయం చర్చలు చేయవలసి, గురించి ఆలోచించటం లేదు
 ఈ విషయం బ్లా బ్లా బ్లా, మీరు ఈవెంట్స్ పరంగా విషయం మాట్లాడు ఎందుకంటే.
 ఇది జరిగినప్పుడు, ఈ జరుగుతుంది. ఇది జరిగినప్పుడు, ఆ జరుగుతుంది.
 ఇత విషయాలు ట్రిగ్గర్ ఉంటే, ఆ గొప్ప.
 కానీ మీరు క్లిష్టమైన కోడ్ ప్రయత్నించండి మరియు చేయాలనుకుంటున్నారా లేదు
 మీరు, అదే సమయంలో బహుళ విషయాలు చెందేందుకు చేస్తున్నారు
 మీరు మీరే ఒక తలనొప్పి ఇవ్వాలని ఎందుకంటే.
 

అన్ని కుడి. ఇప్పుడు మేము మా పేజీ ఈవెంట్స్ నిర్వహించడానికి పొందవచ్చు,
 కాని నా వినియోగదారు ఒక బటన్ను క్లిక్ పిలవబడు.
 నాకు తిరిగి సర్వర్కు ఆ అభ్యర్థన పంపండి అనుకుంటే
 ఒక కొత్త పేజీ రీలోడ్ అవసరం ఎందుకంటే కానీ నేను, పేజీ రీలోడ్ వద్దు
 ప్రతి సమయం దుర్భరమైన గెట్స్, మరియు ఎందుకు నేను చేయాలి
 మళ్ళీ శీర్షిక లాగేందుకు, మళ్ళీ ఫుటర్కు,
 మరియు అన్ని పేజీ యొక్క అంశాలను మళ్ళీ
 కేవలం గ్రీటింగ్ లేదా సమయం రిఫ్రెష్?
 మేము అజాక్స్ లాగ ఎందుకు కాబట్టి ఆ.
 మనం అజాక్స్ తో ఇక్కడ చేయవచ్చు, మేము, అన్ని కుడి చెప్పగలను ఉంది
 నేను సర్వర్కు కొన్ని డేటా పంపాలని,
 మరియు నేను నా పేజీ నవీకరించవచ్చు తిరిగి ఒక స్పందన కావాలి,
 లేదా బహుశా కేవలం తప్పనిసరిగా యూజర్ ఏదైనా చూపించు లేదు కొన్ని క్రమసూత్ర లేక్కించాలంటే.
 మీరు దీన్ని చేయాలి? బాగా, మీరు మాట్లాడటానికి అవసరం ఒక URL అవసరం.
 మీ సర్వర్ కేవలం అద్భుతంగా ఎక్కడా నుండి లో వినడానికి కాదు.
 మీరు ఈ డేటా పంపిస్తున్నాం ఒక నిర్దిష్ట స్థలం కలిగి ఉండాలి.
 మరియు మీరు కూడా పంపడానికి కొన్ని డేటా అవసరం, లేదా బహుశా ఇది ఒక dataless ప్రశ్న ఉంది.
 మీరు హే, నేను సజీవంగా, లేదా అలాంటిదే ఉన్నాను, తిరిగి సర్వర్కు పింగ్ మరియు చెప్పాలనుకోవడం.
 మరియు అప్పుడు మీరు ప్రధానంగా విజయం సంభాలించే ఫంక్షన్ కావలసిన.
 మీరు మీ సర్వర్ నుండి కొంత సమాచారాన్ని తిరిగి పొందడానికి లెట్,
 మరియు మీరు వారి పేజీలో వినియోగదారు యొక్క టైటిల్ మార్చడానికి కావలసిన.
 కాబట్టి మీరు సమాచారాన్ని తిరిగి పొందుతారు,
 మరియు మీరు స్క్రీన్ ఆ పుష్.
 పేజీ సిద్ధంగా ఉంది ఏమి జరుగుతుంది,, ఉంది
 మీరు greeter అని ఈ బటన్ కోసం క్లిక్ ఫంక్షన్ ఒక సృష్టించడానికి. బటన్ నెట్టడమే ఏమి ఈ అప్పుడు చేస్తుంది, ఉంది,
 మీరు greetings.php మాట్లాడటానికి, మీరు, ఒక POST అభ్యర్థనను
 మరియు మీరు, నాతో మీ పేజీ నుండి ఏదో చెప్పేది.
 మేము నిజంగా, ఆ కలిగింది, కానీ greetings.php లేదు
 లెట్ యొక్క కేవలం చెప్పే, "హలో వరల్డ్." తిరిగి ఇస్తుంది
 కాబట్టి మేము, ", హలో వరల్డ్" ఈ మళ్లీ వచ్చి ఈ విజయం
 ఏమీ తప్పు వెళుతుంది ఊహించి తర్వాత మేము ఈ లక్ష్యాన్ని స్థలం వెళ్ళండి
 మేము పేర్కొన్న మరియు మేము అక్కడే ప్రతిస్పందన చూసీ.
 మరియు ఈ ఒక అజాక్స్ ప్రశ్న అప్ సెట్ యొక్క అతి సాధారణ మార్గం.
 

చాలా త్వరగా, రాబ్ విధమైన, ఇప్పటికే వివరించినాడు
 విషయాలు తప్పు వెళ్ళే, చెడు విషయాలు జరుగుతుంది,
 కాబట్టి మీరు ఈ HTTP ప్రతిస్పందన సంకేతాలు మిమ్మల్ని పరిచయం మీరు.
 ఏ వీటిలో ప్రతిదీ ఓకే వెళ్ళింది, 200, వంటి, కేవలం ఉన్నాయి.
 ఏదో, చెడు విషయాల జరిగింది.
 ఇది సాధారణంగా మీరు గుర్తు విషయం.
 కానీ ఈ అన్ని తెలుసు మంచిది.
 చివరకు, ఒకసారి మేము ఆ అన్ని ద్వారా మారారు,
 మేము, డిజైన్ గురించి చాలా త్వరగా మాట్లాడటానికి అవసరం
 మరియు తర్వాత మీరు అన్ని వదిలి తెలియజేయవచ్చు.
 డిజైన్. మీరు గుర్తుంచుకోవాలనుకుంటున్న థింగ్స్.
 ఈ సమాధానం రకం, వస్తారు?
 వారు కోసం ఇది ఉపయోగించబోయే? నా వినియోగదారులు ఏమి శ్రద్ధ లేదు?
 వారు ఏమి గురించి పట్టించుకోను?
 మీరు కేవలం ఒక అనువర్తనం తిరిగేందుకు మరియు పెరుగుతాయి తెలియజేయాలనుకుంటున్నాము లేదు
 మరియు ఈ దిగ్గజం, మీరు కూడా పూర్తి కాదు అన్ని వినియోగించే విషయం మారింది.
 మీరు కావలసిన వివిక్త లక్ష్యాలను మరియు ప్రణాళికలు మరియు విషయాలు కావాలి.
 అది అప్రయత్నంగా చేయండి. ఈ అన్ని, ప్రధానంగా, చెప్పారు
 సులభం యూజర్ ఉపయోగించడానికి కోసం చేయుము నిజానికి, ఈ స్లయిడ్ వంటి టెక్స్ట్ యొక్క ఒక భారీ బొట్టు ఉంది చేయటం లేదు.
 మీరు కేవలం అది ఎవరైనా లో వెళ్ళడానికి కోసం చాలా సులభం ఉన్న ఏదో ఉండాలనుకుంటున్నాను
 మరియు వారు చేయాలనుకుంటున్నారా ఏమి.
 మీరు వాటిని 5 పేజీలను నావిగేట్ ఉంటుంది వద్దు
 మీ సైట్ యొక్క మీ ప్రధాన పని చెయ్యడానికి.
 Google ముందు 5 పేజీలను కలిగి ఉంటే మీరు కూడా ఏదో శోధించండి కాలేదు,
 ఎవరూ దానిని ఉపయోగించే.
 చివరికి, కాగితం నమూనా, దృష్టి సమూహం.
 మంచి డిజైన్ మరియు పరీక్ష పద్ధతులు ఉన్నాయి.
 మీరు కోసం పనిచేస్తుంది భావించడం వలన,
 ఎవరైనా అది పనిచేస్తుంది ఆలోచించడం కాదు.
 కానీ అవును, అంతే.
 [CS50.TV]